快速理解Java中的七种单例模式

饿汉式(推荐)

package concurencyv2.chapter1;
public class SingletonV2 {
    private static final SingletonV2 instance = new SingletonV2();
    private SingletonV2() {}
    public static SingletonV2 getInstance() {
        return instance;
    }
}

优点：初试化静态的instance创建一次。如果我们在Singleton类里面写一个静态的方法不需要创建实例，它仍然会早早的创建一次实例。而降低内存的使用率。

缺点：没有lazy loading的效果，从而降低内存的使用率。

单线程下

package concurencyv2.chapter1;
public class SingletonV1 {
    private static SingletonV1 instance = null;
    private SingletonV1() {}
    public SingletonV1 getInstance() {
        if(null == instance)
            instance = new SingletonV1();
        return SingletonV1.instance;
    }
}

注解: Singleton的静态属性instance中，只有instance为null的时候才创建一个实例，构造函数私有，确保每次都只创建一个，避免重复创建。

缺点：4只在单线程的情况下正常运行，在多线程的情况下，就会出问题。例如：当两个线程同时运行到判断instance是否为空的if语句，并且instance确实没有创建好时，那么两个线程都会创建一个实例。

懒汉式

package concurencyv2.chapter1;
public class SingletonV3 {
    private SingletonV3() {
    }
    private static SingletonV3 instance;
    public synchronized static SingletonV3 getInstance() {
        if(null == instance)
            instance = new SingletonV3();
        return SingletonV3.instance;
    }
}

注解：在单线程的基础上加上了同步锁，使得在多线程的情况下可以用。例如：当两个线程同时想创建实例，由于在一个时刻只有一个线程能得到同步锁，当第一个线程加上锁以后，第二个线程只能等待。第一个线程发现实例没有创建，创建之。第一个线程释放同步锁，第二个线程才可以加上同步锁，执行下面的代码。由于第一个线程已经创建了实例，所以第二个线程不需要创建实例。保证在多线程的环境下也只有一个实例。

缺点：每次通过getInstance方法得到singleton实例的时候都有一个试图去获取同步锁的过程。而众所周知，加锁是很耗时的。能避免则避免。

double check

package concurencyv2.chapter1;
public class SingletonV4 {
    private SingletonV4() {
    }
    private static SingletonV4 instance;
    public static SingletonV4 getInstance() {
        if(null == instance) {
            synchronized (SingletonV4.class) {
                if(null == instance)
                    instance = new SingletonV4();
            }
        }
        return SingletonV4.instance;
    }
}

注解：只有当instance为null时，需要获取同步锁，创建一次实例。当实例被创建，则无需试图加锁。

缺点: 可能会出现空指针异常，一个线程获取了同步锁，并且创建了，但是还没有完成初始化。 另外一个线程直接getInstace,因此这个线程可能获取到的对象，有些地方没有初始化完成，造成引用的空指针现象。

double check and add volatile (推荐)

package concurencyv2.chapter1;
public class SingletonV5 {
    private SingletonV5() {
    }
    private static volatile SingletonV5 instance;
    public static SingletonV5 getInstance() {
        if(null == instance) {
            synchronized (SingletonV5.class) {
                if(null == instance)
                    instance = new SingletonV5();
            }
        }
        return SingletonV5.instance;
    }
}

优点：在instance上添加了volatile，使得每次执行读操作的时候保证写操作已经完成.

静态内部类 (推荐)

package concurencyv2.chapter1;
public class SingletonV6 {
    private SingletonV6() {}
    private static class SingletonHolder {
        public static final SingletonV6 instance = new SingletonV6();
    }
    public SingletonV6 getInstance() {
        return SingletonHolder.instance;
    }
}

枚举enum

package concurencyv2.chapter1;
public class SingletonV7 {
    private SingletonV7() {
    }
    private enum Singleton {
        SINGLETON;
        private SingletonV7 instance;
        Singleton() {
            instance = new SingletonV7();
        }
    }
    public static SingletonV7 getInstance() {
        return Singleton.SINGLETON.instance;
    }
}

利用enum只初始化一次的特性，保证了线程安全性.