设计模式——单例模式

3.单例模式

3.1最简单的单例

public class Singleton {
	
	private static Singleton instance = new Singleton();
	
	private Singleton() {
		
	}
	
	public static Singleton getInstance() {
		return instance;
	}
}

线程安全，如果需要复杂的初始化，这时候应该写一个static {} 静态代码块，完成对instatnce的初始化。

3.2 延迟创建

public class UnThreadSafeSingelton {
	private static UnThreadSafeSingelton instance ;
	public static UnThreadSafeSingelton getInstance() {
		if(instance == null) {
			instance = new UnThreadSafeSingelton();
		}
		
		return instance;
	}
}

这个就是网上称的懒汉式，线程不安全。

在高并发的时候，可能线程A刚判断完if（）语句后，线程B同样也判断if()语句，都为空，都各自创建一个新的对象，这样就不能保证全局唯一。

3.3 Double-Check Locking

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

正是因为使用了两次检查，所以称为double-checked locking模式

为什么要加这个volatile关键字？

volatile具有可见性的特点，线程能自动发现volatile变量的最新值，如果instance实例化成功，其他线程能立刻发现。

volatile保证了可见性，当第一个线程完成了instance初始化之后，能马上的把instance放到计算机主内存中，而不是CPU的高速内存中。

如果没有volatile，可能会导致，还没来得及让instance存入主内存中，线程1执行完后，线程2就已经拿到synchronized锁开始判断第二个if了，导致建立了两个对象。

关于volatile关键字 Java并发编程：volatile关键字解析 - Matrix海子 - 博客园 (cnblogs.com)

这篇博文总结的很好

3.4 Initialization

public class LazyLoadedSingleton {
	
	private LazyLoadedSingleton() {
		
	}
	
	private static class LazyHolder{
		private static final LazyLoadedSingleton singletonInstatnce 
		= new LazyLoadedSingleton();
		
	}
	
	public static LazyLoadedSingleton getInstance() {
		return LazyHolder.singletonInstatnce;
	}
}

这样jvm加载LazyLoadedSingleton类的时候，因为该类没有static属性，所以加载后立刻返回。

当调第一次调用getInstance方法时候，JVM才会加载内部类LazyHolder，完成初始化。不仅线程安全，还有延迟创建的功能。