Java单例类（饿汉式，懒汉式，双重检查锁，静态私有内部类，枚举）-剑指office面试题2

定义：一个类有且仅有一个实例，并且自行实例化向整个系统提供。
作用：解决一个全局使用的类频繁地创建与销毁的问题。
优点：减少内存开销，避免对资源的多重占用。
缺点：没有接口，不能继承。
实现方式：饿汉式，懒汉式，双重检查锁，静态私有内部类，枚举

饿汉式

/* 饿汉式单例类*/
public class Singleton {
    private Singleton(){
    }

    private static Singleton instance = new Singleton();

    public static Singleton getInstance(){
        return instance;
    }
}

缺点：不支持并发，只能在单线程中使用，加载时就已经创建好了实例，不管用不用。

懒汉式

懒汉式（不支持并发）

/* 懒汉式-- 不支持并发 */
public class Singleton2 {
    private Singleton2(){
    }
    private static Singleton2 instance = null;
    private static Singleton2 getInstance(){
        if (instance == null){
            instance = new Singleton2();
        }
        return instance;
    }
}

缺点：不支持并发，只能在单线程中使用。
优点：只有在调用获取实例的方法时才创建实例。

懒汉式（支持并发）

/*饿汉式--支持并发*/
public class Singleton3 {
    private Singleton3(){
    }
    private static Singleton3 instance = null;
    private synchronized static Singleton3 getInstance(){
        if (instance == null){
            instance = new Singleton3();
        }
        return instance;
    }
}

缺点：synchronized锁住了整个方法，当有多个线程需要访问方法时，不管实例有没有创建，都需要排队等待才能拿到实例，效率低。

两个懒汉式的区别：加不加 sybchronized。

双重检查锁、volatile(常用)

public class Singleton4 {
    private Singleton4(){
    }

    private volatile static  Singleton4 instance = null;
    private static  Singleton4 getInstance(){
        if (instance == null){ //1
            synchronized (Singleton4.class){
                if (instance == null){ //2
                    instance = new Singleton4();
                }
            }
        }
        return instance;
    }
}

volatile 关键字保证了内存可见性，所有线程都会去主存中取数据而不是在线程的缓存中取，保证了数据的更新能实时地对任何线程可见。
假如有两个线程同时到达了1，它们都去创建实例，这时候如果没有第二次判断，就会多次创建实例了。二次判断保证了多线程下只创建一个实例。

静态内部私有类（常用）

public class Singleton5 {
    private Singleton5(){

    }

    private static class Singleton5Holder{
        private static Singleton5 instance = new Singleton5();
    }

    public static Singleton5 getInstance(){
        return Singleton5Holder.instance;
    }
}

静态内部类不会随着外部类的加载而加载 ,只有静态内部类的静态成员被调用时才会进行加载（实例化）。同时，虚拟机会保证一个类的构造器方法在多线程环境中被正确地加载，同步，如果多个线程同时去初始化一个类，那么只有一个线程去执行这个类的。所以这种方法支持多并发，效率高。

枚举

public enum Singleton6 {
    INSTANCE;
}

外部调用由原来的Singleton.getInstance变成了Singleton.INSTANCE了。