Java单例模式汇总详解

一、饿汉式

饿汉式其优点十分明显线程安全，效率高，缺点也十分显著，即不能延迟加载（懒加载）。

**
 * 饿汉式单例模式,线程安全，效率高，不能延迟加载(容易造成浪费)
 */
class Singleton1{
	
	//提供静态属性
	private static Singleton1 instance = new Singleton1();
	
	//私有构造器
	private Singleton1(){
		
	}
	
	//
	public static Singleton1 getInstance(){
		return instance;
	}
}

饿汉式，顾名思义，即一开始就初始化静态属性，这也就是它不能进行延迟加载的原因，针对这个缺点，推出了懒汉单例模式。

二、懒汉式

懒汉式解决了饿汉式不能延迟加载的问题，而且线程安全，但由于是加了synchronized，效率低，故也有缺点。

/**
 * 懒汉式，线程安全，效率低（有synchronized），能延迟加载
*/
class Singleton2{
	
	//提供静态属性
	private static Singleton2 instance;
	
	//私有化构造器
	private Singleton2(){
		
	}
	
	//获取对象
	public static synchronized Singleton2 getinstance(){
		
		if(instance==null){
			instance = new Singleton2();
		}
		return instance;
	}
}

对此，提出了懒汉式的改进版，如下：

/**
 * 懒汉模式改进版
 */
class Singleton21{
	
	//提供静态属性
	private static Singleton21 instance;
	
	//构造私有构造函数
	private Singleton21(){
		
	}
	
	//获取对象
	public static Singleton21 getInstance(){
		//提高效率
		if(instance==null){
			synchronized(Singleton21.class){
				//为了避免多次创建对象
				if(instance==null){
							instance=new Singleton21();
					
				}
			}
		}
		return instance;
	}
}

此处，将加锁更加地细粒度化，将锁加在对象上，而且外层多了一层判断，当instance为空时，才进行加锁，不为空时直接返回instance，这样就效率更高，不会重复加锁

三、双重检测锁模式

/**
 * 双重检测锁模式
 */
class Singleton3{
	
	//提供静态属性
	private static Singleton3 instance;
	
	//构造私有构造函数
	private Singleton3(){
		
	}
	
	//获取对象
	public static Singleton3 getInstance(){
		if(instance==null){
			Singleton3 sc;
			synchronized(Singleton3.class){
				sc=instance;
				if(sc==null){
					synchronized(Singleton3.class){
						if(sc==null){
							sc=new Singleton3();
						}
					}
					instance=sc;
				}
			}
		}
		return instance;
	}
}

该模式也解决了效率问题和线程安全问题，但是由于底层编译器优化问题和jvm的底层代码，有时会出现错误，所以不推荐使用。

四、静态内部类模式

该模式也是针对效率和安全问题提出来的单例设计模式，使用静态内部类实现，代码如下

/**
 * 静态内部类模式
 */
class Singleton4{
	
	//静态内部类提供静态属性
	public static class Singleton4ClassInstance{
		private static final Singleton4 s = new Singleton4();
	}
	
	
	//构造私有构造函数
	private Singleton4(){
		
	}
	
	//获取对象
	public static Singleton4 getInstance(){
		return Singleton4ClassInstance.s;
	}
	
	
}

使用静态内部类，当使用时才初始化该类，效率高，又由于类的天然线程安全，保证了线程的安全问题

五、枚举模式

运用枚举实现单例，但缺少延迟加载

/**
 * 枚举模式，线程安全，没有延迟加载
*/
public enum  Singletont {
	
	INSTANCE;
	
	//添加需要的操作
	public void singletonoperation(){
		
	}
}

如有问题，欢迎指出，互相学习！！