Java单例模式
java单例模式是为了让全局只实例化一个对象，常用的方式包括懒汉模式、饿汉模式，考虑到线程安全，又分线程安全和线程不安全。单利的特性决定了其没有public的构造函数，懒汉/饿汉模式取决于实例化的时机，安全/非安全取决于是否支持多线程并发调用，根据这些特点，今天记录一下我所知道的10种实现单例模式的写法。
创建方法汇总
1、普通饿汉模式（安全）
/**
* 单例模式
*/
public class SingleTest {
private static final SingleTest singleTest = new SingleTest();
private SingleTest() {
}
/**
* 获取单例模式
*
* @return
*/
public static SingleTest getSingleTest() {
return singleTest;
}
}
点评：私有构造函数、静态final对象，调用该类一上来就实例化，所以是饿汉、线程安全。
2、普通饿汉模式变形（线程安全）
/**
* 单例模式
*/
public class SingleTest {
private static final SingleTest singleTest;
static {
singleTest = new SingleTest();
}
private SingleTest() { }
/**
* 获取单例模式
*
* @return
*/
public static SingleTest getSingleTest() {
return singleTest;
}
}
点评：利用静态代码块，完成对于singleTest的实例化，原理和方法1一样，饿汉、安全。
3、枚举类型单例模式（饿汉、安全）
/**
* 单例模式
*/
public enum SingleTest {
INSTANCE;
public void methodXXX(){
}
}
点评：利用枚举的特性，保证只有一个对象，且线程安全，所以是饿汉、安全
4、普通懒汉模式（不安全）
/**
* 单例模式
*/
public class SingleTest {
private static SingleTest singleTest;
private SingleTest() { }
/**
* 获取单例模式
*
* @return
*/
public static SingleTest getSingleTest() {
if (singleTest == null) {
singleTest = new SingleTest();
}
return singleTest;
}
}
点评：在使用的时候判断是否实例化，没有则先实例化，多线程切换时，可能会重复创建，所以懒汉、不安全。
5、安全的懒汉模式（安全）
/**
* 单例模式
*/
public class SingleTest {
private static SingleTest singleTest;
private SingleTest() {
}
/**
* 获取单例模式
*
* @return
*/
public synchronized static SingleTest getSingleTest() {
if (singleTest == null) {
singleTest = new SingleTest();
}
return singleTest;
}
}
点评：无它，加了一个同步操作，保证安全，所以是懒汉、安全。但都知道synchronized性能低。
6、双重校验的懒汉模式（安全，非绝对）
/**
* 单例模式
*/
public class SingleTest {
private static SingleTest singleTest;
private SingleTest() {
}
/**
* 获取单例模式
*
* @return
*/
public static SingleTest getSingleTest() {
if (singleTest == null) {
synchronized(SingleTest.class){
if(singleTest == null){
singleTest = new SingleTest();
}
}
}
return singleTest;
}
}
点评：双重校验，优化了性能，但是由于可见性以及线程内存和主存的关系，所以是懒汉、非绝对安全。
7、升级版双重校验懒汉模式（安全）
/**
* 单例模式
*/
public class SingleTest {
//添加volatile，防止重排并保证可见性。
private volatile static SingleTest singleTest;
private SingleTest() {
}
/**
* 获取单例模式
*
* @return
*/
public static SingleTest getSingleTest() {
if (singleTest == null) {
synchronized(SingleTest.class){
if(singleTest == null){
singleTest = new SingleTest();
}
}
}
return singleTest;
}
}
点评：添加volatile关键词，防止重排，保证可见性，所以是懒汉、安全。
8、静态内部类，实现懒加载（安全）
/**
* 单例模式
*/
public class SingleTest {
private static class SingleGet {
private static final SingleTest singleTest = new SingleTest();
}
private SingleTest() {
}
/**
* 获取单例模式
*
* @return
*/
public static SingleTest getSingleTest() {
return SingleGet.singleTest;
}
}
点评：利用静态内部类的加载特性，实现懒加载，保证线程安全，所以是懒汉、安全。
9、CAS自旋实现（懒汉、安全）
/**
* 单例模式
*/
public class SingleTest {
/**
* 利用AtomicReference，保证操作的
*/
private static final AtomicReference INSTANCE = new AtomicReference();
private SingleTest() {
}
/**
* 获取单例模式
*
* @return
*/
public static SingleTest getSingleTest() {
for (; ; ) {
SingleTest current = INSTANCE.get();
if (current != null) {
return current;
}
current = new SingleTest();
if (INSTANCE.compareAndSet(null, current)) {
return current;
}
}
}
}
点评：通过CAS自旋实现安全，所以是懒汉、安全。
10、仿android.util下的Singleton，获取单例对象（懒汉、安全）
Singleton.java
public abstract class Singleton {
private T mInstance;
protected abstract T create();
public final T get() {
synchronized (this) {
if (mInstance == null) {
mInstance = create();
}
return mInstance;
}
}
}
单例实现
/**
* 单例模式
*/
public class SingleTest {
private static final Singleton SINGLETON = new Singleton() {
@Override
protected Object create() {
return new SingleTest();
}
};
private SingleTest() {
}
/**
* 获取单例模式
*
* @return
*/
public static SingleTest getSingleTest() {
return SINGLETON.get();
}
}
点评：利用Singleton这个对象的特性，创建的是一个安全（synchronized）、唯一的对象。
11、其他
综合考虑，只要实现该对象在进程中理论上只创建一次，那么就对得起单例模式这个名字，不同的线程获取到的都是同一个对象，那么就是安全的，在获取时实例化，那么就是懒汉模式。可以看到上面的各种方法，都是在这三点上使用不同的技术方案来完成而已。
知识点汇总
synchronized可以保证安全，但会阻塞线程，消耗性能，所以要最小化的使用同步，来保证安全。
每个线程有自己的缓存，虚拟机有主存，数据存在主存上，各个线程拿一份到自己的缓存中操作，然后在刷新到主存，这样保证效率，但是也造成了线程安全问题。
volatile保证原子操作可见性（读的操作从主存取，写的操作立即刷新到主存），防止CPU指令重排（内存屏障）
静态代码块比构造方法先执行，只执行一次，代码块每次实例化对象都会被执行。
如果单例类被标记为可序列化，需要重写readResolve方法来确保在readObject时不创建新的对象。
枚举可以防止序列化。
ThreadLocal实现的是每一个线程一个对象，多个线程会有多个对象，所以我认为不是单例模式。
枚举模式最简洁，饿汉模式也很简洁，双重校验用的挺多，看各位写代码喜好吧。