单例模式

1、懒汉式(线程不安全)

public class Singleton {
    private static Singleton instance;
    private Singleton (){}


    public static Singleton getInstance() {
	if (instance == null) {
	    instance = new Singleton();
	}
	return instance;
    }
}

但是这种方式并不是真正的单例模式，因为这是线程不安全的。

2、懒汉式(线程安全)

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

3、饿汉式(静态内部类实现lazy loading)

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

这种方式可以实现lazy loading的效果，在类加载的时候，Singleton并没有实现实例化，这是因为SingletonHolder并没有显示的调用，只有在singletonHolder实例化的时候才会实例化对象Singleton。这样可以实现lazy loading的效果。

4、双重校检锁

public class Singleton {
    private volatile static Singleton singleton;
    private Singleton (){}
    public static Singleton getSingleton() {
	if (singleton == null) {
	    synchronized (Singleton.class) {
		if (singleton == null) {
		    singleton = new Singleton();
		}
	    }
	}
	return singleton;
    }
}

总结：所谓双重校检锁指的是：并不是每次进入getInstance方式都需要同步，而不是先同步，进入方法后，先检查实例是否存在，如果不存在才进入下面的同步块，这是第一次检查。进入同步块后，再次检查实例是否存在，如果不存在就在同步块之中创建一个实例，这是第二重检查。这样一来，就只需要同步一次了，从而减少了多次在同步情况下进行判断所浪费的时间。

双重校检机制的实现会使用一个关键字volatile，这个关键字的意思是：被volatile修饰的变量的值，将不会被本地线程所缓存，所有对本变量的读写都是直接操作共享内存的，从而确保多个线程可以正确的处理该变量。