单例由浅入深

 /*
 * 单例设计模式：解决一个类在内存中只存在一个对象的问题
 *
 * 1.私有化构造函数
 *         先禁止其他程序建立该类对象
 * 2.在类中创建一个本类对象
 *         在本类中自定义一个对象供其他程序访问
 * 3.提供一个方法可以获取到该对象
 *         对外提供访问方式，方便其他程序对自定义对象的访问
 */

---

饿汉式

/*
 * 饿汉式：
 * 		开发一般用饿汉式，简单安全
 * 		类一进内存，就创建了对象
 */
class Single{
	private final static Single single = new Single();
	
    private Single(){}
	
	public static Single getInstance(){
		return single;
	}
}

class Single {
    private final static Single single;
    static {
        single = new Single();
    }

    private Single() {}

    public static Single getInstance() {
        return single;
    }
}

---

懒汉式 

• 线程不安全：

//懒汉式
public class Single {
	//持有私有静态实例，防止被引用，此处赋值为null
	private static Single instance = null;
 
	//私有构造方法，防止被实例化
	private Single() {
	}
 
	//静态工厂方法，创建实例
	public static Single getInstance() {
		if (instance == null) {
			instance = new Single();
		}
		return instance;
	}
}

• 线程安全： 

/*
 * 懒汉式：
 * 		对象在方法被调用时，才初始化，也叫做对象的延时加载
 * 		类进内存，对象还未存在，调用了getInstance方法时，才建立对象
 */
class Single{
    //volatile防指令重排
	private static volatile Single single;

	private Single(){}
	
	//synchronized:一个程序进来调用，另一个程序就会被挡在外面进不来
	//缺点：程序效率大大降低
//    public static synchronized Single getInstance(){
//		if(single == null){
//			single = new Single();
//		}
//		return single;
//	}
	
    //双检锁
	public static Single getInstance(){
		//第二个程序进来时直接判断到single不为空，判断锁的次数减少了
		if(single == null){
			synchronized(Single.class){
				if(single == null){
					single = new Single();
				}
			}
		}
	}
}

•  最优：

public class Singleton {

    private Singleton() {}

    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }
}
//静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingletonInstance 类，从而完成Singleton的实例化。（懒加载）
//类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。