懒汉式
/**
* 懒汉
* 以下实现中，私有静态变量 instance 被延迟实例化，这样做的好处是，如果没有用到该类，那么就不会实例化 instance，从而节约资源。
这个实现在多线程环境下是不安全的，如果多个线程能够同时进入 if (instance == null) ，并且此时 instance 为 null，那么会有多个线程执行 instance = new Singleton(); 语句，这将导致实例化多次 instance。
*
*/
public class Singleton1 {
private static Singleton1 instance;
private Singleton1() {
}
public static Singleton1 getInstance() {
if(instance == null){
instance = new Singleton1();
}
return instance;
}
}
懒汉式加锁
/**
* 懒汉 加锁
* 只需要对 getInstance() 方法加锁，那么在一个时间点只能有一个线程能够进入该方法，从而避免了实例化多次 instance。
但是当一个线程进入该方法之后，其它试图进入该方法的线程都必须等待，即使 instance 已经被实例化了。这会让线程阻塞时间过长，因此该方法有性能问题，不推荐使用。
*/
public class Singleton2 {
private static Singleton2 instance;
private Singleton2(){
}
public static synchronized Singleton2 getInstance(){
if(instance == null){
instance = new Singleton2();
}
return instance;
}
}
双重锁懒汉式DCL
/**
* 双重锁懒汉模式(Double Check Lock)
* DCL模式的优点就是，只有在对象需要被使用时才创建，第一次判断 INSTANCE == null为了避免非必要加锁，
* 当第一次加载时才对实例进行加锁再实例化。这样既可以节约内存空间，又可以保证线程安全。
* 但是，由于jvm存在乱序执行功能，DCL也会出现线程不安全的情况。
* instance = new Singleton5();在JVM中的执行步骤
* 1.在堆内存开辟内存空间。
* 2.在堆内存中实例化SingleTon里面的各个参数。
* 3.把对象指向堆内存空间。
* <p>
* 由于jvm存在乱序执行功能，所以可能在2还没执行时就先执行了3，如果此时再被切换到线程B上，由于执行了3，instance 已经非空了，会被直接拿出来用，这样的话，就会出现异常。这个就是著名的DCL失效问题。
*/
public class Singleton5 {
private static Singleton5 instance;
public Singleton5() {
}
public static Singleton5 getInstance() {
if (instance == null) {
synchronized (Singleton5.class) {
if (instance == null) {
instance = new Singleton5();
}
}
}
return instance;
}
}
饿汉式
/**
* 饿汉
*
线程不安全问题主要是由于 instance 被实例化多次，采取直接实例化 instance 的方式就不会产生线程不安全问题。
但是直接实例化的方式也丢失了延迟实例化带来的节约资源的好处。
饿汉模式在类被初始化时就已经在内存中创建了对象，以空间换时间，故不存在线程安全问题。
*/
public class Singleton3 {
private static final Singleton3 instance = new Singleton3();
private Singleton3(){
}
public static Singleton3 getInstance(){
return instance;
}
}
静态内部类
/**
* 静态内部类
* 当Singleton4类加载时，静态内部类SingletonHolder没有被加载进内存，只有当调用getInstance()方法时，
* 才会触发SingletonHolder.INSTANCE，SingletonHolder才会被加载，此时初始化INSTANCE实例，并且JVM确保INSTANCE只被实例化一次
* 这种方式不仅具有延迟初始化的好处，而且JVM提供了对线程安全的支持
*
*
*/
public class Singleton4 {
private Singleton4(){}
private static class SingletonHolder{
private static final Singleton4 INSTANCE = new Singleton4();
}
public static Singleton4 getInstance(){
return SingletonHolder.INSTANCE;
}
}
参考android.util.Singleton 实现Singleton帮助器类
/**
* Singleton helper class for lazily initialization.
* 用于延迟初始化的Singleton帮助器类。
* @param <T>
*/
public abstract class Singleton<T> {
/**
* 一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：
* 1.保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。
* 2.禁止进行指令重排序。
*/
private volatile T mInstance;
protected abstract T create();
public final T get() {
if (mInstance != null) {
synchronized (this) {
if (mInstance == null) {
mInstance = create();
}
return mInstance;
}
}
return mInstance;
}
}
/**
* 使用Singleton帮助器类实现单例
*/
public class CommonUtil {
private CommonUtil() {}
private CommonUtil getInstance(){
return instance.get();
}
private static final Singleton<CommonUtil> instance = new Singleton<CommonUtil>() {
@Override
protected CommonUtil create() {
return new CommonUtil();
}
};
}
参考：
volatile关键字解析
静态内部类单例原理
