单例模式

用于创建单一类。例如一些工具类等。

主要有以下四种实现：

lazy load，线程不安全

public class UnsafeLazySingleton {

    private static UnsafeLazySingleton instance;

    private UnsafeLazySingleton() {
    }

    public static UnsafeLazySingleton getInstance() {
        if (instance == null) {
            instance = new UnsafeLazySingleton();
        }
        return instance;
    }
}

lazy load，线程安全，但是每次获取需要锁，效率较差

public class SafeLazySingletonWithLock {

    private static SafeLazySingletonWithLock instance;

    private SafeLazySingletonWithLock() {
    }

    public static synchronized SafeLazySingletonWithLock getInstance() {
        if (instance == null) {
            instance = new SafeLazySingletonWithLock();
        }
        return instance;
    }
}

线程安全

public class UnLazySingleton {

    private static UnLazySingleton instance = new UnLazySingleton();

    private UnLazySingleton() {
    }

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

双检索

public class DoubleCheckedSingleton {

    private volatile static DoubleCheckedSingleton singleton;

    private DoubleCheckedSingleton() {
    }

    public static DoubleCheckedSingleton getSingleton() {
        if (singleton == null) {
            synchronized (DoubleCheckedSingleton.class) {
                if (singleton == null) {
                    singleton = new DoubleCheckedSingleton();
                }
            }
        }
        return singleton;
    }
}

推荐最后一种方式，即实现了lazy load，又是线程安全，并且只有在初次加载并发的时候需要锁，其他时候不会用到锁，效率也有保障。PS：首次并发的时候出现冲突，都运行到代码10，当一个线程成功初始化后，由于单例是volatile修饰的，其他线程可见，代码11判断后不会发生重复定义，保证线程安全。