你真的会单例吗？单例的八种写法

àì夳堔傛蜴生んèń 2024-04-19 15:19 98阅读 0赞

说起单例设计模式因该很多人都不陌生，按理说只有接触过java的都应该知道这个设计模式，但是你真的会写吗？还是说只会懒汉式和饿汉式？其实日常工作中随便掌握一种就已经可以了，但是我们身为java程序员应该不断的学习，即使用不到但是也要来了解以下，接下来我就来给你们写单例的八种写法，其中只有四种是能有并且没有问题的，其他的都有问题

写法一：传统的饿汉式

class Singleton01{ 
    	private static final Singleton01 INSTANCE = new Singleton01();
    	
    	private Singleton01(){ }
    	
    	public static Singleton01 getInstance(){ 
    		return INSTANCE;
    	}
    }
    
    public class Main{ 
    	public static void main(String[] args){ 
    		Singleton01 instance = Singleton01.getInstance();
    	}
    }

这种就是传统的饿汉式，相信你们并不陌生，这种其实已经很好了，在工作中就写这种也没有任何问题，但是会有些人觉得这个太浪费资源，因为只要去加载这个类，那么这个实例就会创建

写法二：有问题的写法，懒汉式

class Singleton02{ 
    	private static volatile Singleton02 instance;
    	
    	private Singleton02(){ }
    	
    	public static Singleton02 getInstance(){ 
    		if(instance == null){ 
    			instance = new Singleton02();
    		}
    		return instance;
    	}
    }
    
    public class Main{ 
    	public static void main(String[] args){ 
    		Singleton02 instance = Singleton02.getInstance();
    	}
    }

这种写法在多线程的情况下不能保证只有一个实例，所以这是有问题的

写法三：加锁，懒汉式

class Singleton03{ 
    	private static volatile Singleton03 instance;
    	
    	private Singleton03(){ }
    	
    	public static synchronized Singleton03 getInstance(){ 
    		if(instance == null){ 
    			instance = new Singleton03();
    		}
    		return instance;
    	}
    }
    
    public class Main{ 
    	public static void main(String[] args){ 
    		Singleton03 instance = Singleton03.getInstance();
    	}
    }

这种写法每次去拿对象的时候都会加锁，我们都知道加锁会导致效率变慢

写法四：判断加锁，懒汉式

class Singleton04{ 
    	private static Singleton04 instance;
    	
    	private Singleton04(){ }
    	
    	public static volatile Singleton04 getInstance(){ 
    		if(instance == null){ 
    			synchronized(Singleton04.class){ 
    				instance = new Singleton04();
    			}
    			
    		}
    		return instance;
    	}
    }
    
    public class Main{ 
    	public static void main(String[] args){ 
    		Singleton04 instance = Singleton04.getInstance();
    	}
    }

这种写法虽然对比上面那中效率高了些，但是在多线程的响应下，他还是不能保证只有一个实例

写法五：双重判断加锁，懒汉式

class Singleton05{ 
    
    	private static volatile Singleton05 instance;
    
    	private Singleton05(){ }
    
    	public static Singleton05 getInstance(){ 
    		if(instance == null){ 
    			synchronized(Singleton05.class){ 
    				if(instance == null){ 
    					instance = new Singleton05();
    				}
    				
    			}
    		
    		}
    		
    		return instance;
    	}
    
    
    }

这种写法也很常见，这样只要有一个线程将这个实例创建出来了，就不会执行下面的加锁的那段代码，所以效率还是可以的，只有第一次拿的时候会稍微慢一点，因为第一次要创建对象

写法六：静态内部类的方法

public class Singleton06 { 
    
    	private static class SingletonInstance{ 
    		
    		private static final Singleton06 INSTANCE = new Singleton06();
    		
    	}
    	
    	
    	private Singleton06() { }
    	
    	public static  Singleton06 getInstance() { 
    		return SingletonInstance.INSTANCE;
    		
    	}
    	
    }

这种方式已经够很完美了，通过内部类的方式来保证这个单例，这种写法可能看到过的人就比较少了

写法7：枚举单例

public enum Singleton07 { 
    
    	INSTANCE;
    	
    	
    	
    }

这种才是最最最完美的，也是最简单的，下面还有一种，这种应该写在第二种的，但是由于我个人给忘了，所以就写到最下面吧，

写法八：通过静态代码块，饿汉式

public class Singleton08 { 
    
    	private static final Singleton08 INSTANCE;
    	static { 
    		INSTANCE = new Singleton08();
    	}
    	
    	private Singleton08() { }
    	
    	public static Singleton08 getInstance() { 
    		return INSTANCE;
    	}
    	
    }

这种跟第一种是一样的，也就没有必要说了，看到这里你才是真正的了解这个单例模式了。不加volatile可能在指令重排的时候出问题