单例模式

单例模式：确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。
使用场景：
1.复杂对象，避免对象创建过多消耗系统资源。
2.某种类型的对象只应该有且只有一个。
单例模式的写法：
1.饿汉式

/**
 * 饿汉式
 */
public class Singleton1 {
    private static final Singleton1 instance = new Singleton1();
    private Singleton1(){
    }
    private static Singleton1 getInstance(){
        return instance;
    }
}

优点：在类装载的时候就完成实例化，避免了线程同步的问题。
缺点：浪费内存。
2.懒汉式

/**
 * 懒汉式
 */
public class Singleton2 {

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

优点：实现延时加载和线程同步。
缺点：效率太低，每次调用getInstance方法都需要同步。
懒汉式另一种实现方式，锁实例的代码块不锁方法

/**
 * 懒汉式
 */
public class Singleton2 {

    private static Singleton2 instance= null;
    private Singleton2(){
    }
    private static Singleton2 getInsatance(){
        if (instance == null) {
            synchronized (Singleton2.class){
                instance = new Singleton2();
            }
        }
        return instance;
    }
}

这种方式并不能真正实现线程同步，当多个线程同时进入 if (instance == null) 的判断，那么就会出现多个实例。
3.双重检查模式

/**
 * 双重检查模式
 */
public class Singleton3 {
    /**
     * volatile 关键字的作用：
     * 首先这里有两个东西 工作内存和主内存。工作内存是线程的独有的，而主内存是全局的多个线程中主内存内容才最终有效。
     * 而多个工作内存与主内存之间 jmm是提供机制保证一致性的，什么时候保证呢？线程空闲的时候（毕竟线程一致占据CPU也        
     * 没法去更新），也就是在线程让出CPU后jmm会尝试将主内存的内容刷新到工作内存中。
     * 那volatile是怎么实现的？很简单 工作内存中不保留volatile变量的副本，每个线程对volatile变量的访问直接访问主内存。
     */
    private static volatile Singleton3 instance = null;
    private Singleton3(){}
    public static Singleton3 getInstance(){
        if (instance == null) {
            synchronized (Singleton3.class){
                if (instance == null) {
                    instance = new Singleton3();
                }
            }
        }
        return instance;
    }
}

双重检查模式是使用最多的单例模式，资源利用率高，第一次执行getInstance时单例对象才会被实例化，效率高。高并发的情况下有一定缺陷，但是发生概率比较小。
4.静态内部类模式

/**
 * 静态内部类单例模式
 */
public class Singleton4 {

    private Singleton4(){}
    private static class singletonHolder{
        private static final Singleton4 instance = new Singleton4();
    }

    private static Singleton4 getInstance(){
        return singletonHolder.instance;
    }
}

第一次加载Singleton4类时并不会初始化instance，只有在第一次调用getInstance方法时才会实例instance。这种方式不仅能够保证线程安全，也能够保证单例对象的唯一性，同时实现了延时加载。所以这种方式是推荐使用的单例模式。