单例模式

1.懒汉式和饿汉式的区别

饿汉：类一旦加载，就把单例初始化完成，保证getInstance的时候，单例是已经存在的了
懒汉：只有当调用getInstance的时候，才会去初始化这个单例

1.1线程安全角度

饿汉：天生就是线程安全的，可以直接用于多线程而不会出现问题
懒汉：本身是非线程安全的，需要我们人为控制，接下来的例子会列出如何写线程安全的

1.2性能角度

饿汉：在类创建的同时就实例化一个静态对象出来，不管之后会不会使用这个单例，都会占据一定的内存，但是相应的，在第一次调用时速度也会更快，因为其资源已经初始化完成，
懒汉：会延迟加载，在第一次使用该单例的时候才会实例化对象出来，第一次调用时要做初始化，如果要做的工作比较多，性能上会有些延迟，之后就和饿汉式一样了。

2.饿汉式程序

/**
 * 饿汉式
 */
public class Singleton {
    //一定私有化
    private Singleton(){

    }
    //声明静态变量，在类实例化之前就初始化变量,将对象引用保存
    private static final Singleton instance= new Singleton() ;

    /**
     * 提供获取实例对象的方法
     * @return
     */
    public static  Singleton getInstance(){

        return instance;
    }
}

3.懒汉式程序

3.1线程不安全的懒汉式

/**
 * 常见懒汉式
 * 缺点：线程不安全
 */
public class Singleton2 {
    /**
     * 一定对象私有化
     */
    private Singleton2(){}

    private static Singleton2 instance = null ;

    private static Singleton2 getInstance(){
        if(instance==null){
            instance = new Singleton2();
        }
        return instance;
    }
}

3.2线程安全的懒汉式

/**
 * 常见懒汉式,增加synchronized
 *
 */
public class Singleton3 {
    /**
     * 一定对象私有化
     */
    private Singleton3(){}

    private static Singleton3 instance = null ;

    private static synchronized Singleton3 getInstance(){
        if(instance==null){
            instance = new Singleton3();
        }
        return instance;
    }
}

3.3线程安全的懒汉式（双重检查）

/**
 * 常见懒汉式,双重检查
 * ReentrantReadWriteLock 也采用的双重检查
 *
 */
public class Singleton4 {
    /**
     * 一定对象私有化
     */
    private Singleton4(){}

    private static Singleton4 instance = null ;

    private static synchronized Singleton4 getInstance(){
        if(instance==null){
            synchronized (Singleton4.class){
                if(instance==null){
                    instance = new Singleton4();
                }
            }

        }
        return instance;
    }
}

假设线程一执行到instance = new Singleton4()这句，JVM做了三件事情：

　　1给instance实例分配内存；

　　2初始化instance的构造器；

　　3将instance对象指向分配的内存空间

　　JVM为了优化指令，提高程序运行效率，允许指令重排序。可能顺序：

　　1给instance实例分配内存；

　　2将instance对象指向分配的内存空间；

　　3初始化instance的构造器；

　　这时候，当线程A执行完2后切换到线程B上，这时候instance判断为非空，此时线程B直接返回，然后用到这个对象时，实际还没有初始化。

　　synchronized虽然保证了线程的原子性（要么全部执行，要么一条也不执行），但单条语句编译后形成的指令并不是一个原子操作。
解决这个问题的方法是：禁止指令重排序优化，即使用volatile变量。

3.4静态内部类形式（线程安全）

静态内部类的优点是：外部类加载时并不需要立即加载内部类，内部类不被加载则不去初始化INSTANCE，故而不占内存。即当Singleton6第一次被加载时，并不需要去加载LazyHolder ，只有当getInstance()方法第一次被调用时，才会去初始化INSTANCE,第一次调用getInstance()方法会导致虚拟机加载LazyHolder 类，这种方法不仅能确保线程安全，也能保证单例的唯一性，同时也延迟了单例的实例化。

/**
 * 懒汉式,静态内部类形式
 *
 */
public class Singleton6 {
    /**
     * 一定对象私有化
     */
    private Singleton6(){}
    private static class LazyHolder {
        //final 为了防止内部误操作，代理模式，GgLib的代理模式
        private static final Singleton6 INSTANCE = new Singleton6();
    }

    public static final Singleton6 getInstance() {

        return LazyHolder.INSTANCE;
    }
}

3.5扩展

每个线程有一个对象呢？

/**
 * 懒汉式
 *
 */
public class Singleton5 {
    /**
     * 一定对象私有化
     */
    private Singleton5(){}

    private static ThreadLocal<Singleton5> map = new ThreadLocal<Singleton5>();
    
    private static synchronized Singleton5 getInstance(){
        Singleton5 instance = map.get();
        if(instance == null){
            instance = new Singleton5();
            map.set(instance);
        }
        return instance;
    }
}