优雅的手写一个线程安全的单例模式Javaqq36008321的博客-

单例模式是我们非常常用的设计模式之一。百度百科给出的定义：

单例模式，属于创建类型的一种常用的软件设计模式。通过单例模式的方法创建的类在当前进程中只有一个实例（根据需要，也有可能一个线程中属于单例，如：仅线程上下文内使用同一个实例）

一般，我们为了实现单例模式，通常把构造器私有化，然后通过静态方法和静态变量来获取一个对象。

懒汉式，线程不安全

这种方式是最基础的实现方式，最大的问题是不支持多线程，在多线程模式下会产生线程安全问题。

public class Singleton { private static Singleton singleton; private Singleton() {} public static Singleton getInstance() { if (singleton == null) {             singleton = new Singleton(); } return singleton; } } 

所以我们给getInstance()加synchronized锁，保证它在多线程的情况下使用。但会影响效率。

public class Singleton { private Singleton singleton; private Singleton(){}; public synchronized Singleton getInstance() { if (singleton == null) {             singleton = new Singleton(); } return singleton; } } 

饿汉式

比较常用的一种方法，使用classLoder机制避免了多线程同步问题。但是会产生垃圾对象，浪费内存。

public class Singleton { private static Singleton instance = new Singleton(); private Singleton(){} public static Singleton getInstance() { return instance; } } 

双重校验锁

采用懒加载模式，同样也是线程安全的。采用双锁机制，在多线程模式下也能保持高性能

/**  * 懒汉式单例模式（线程不安全）  * */ public class Singleton { private static Singleton singleton; private Singleton() {} public static Singleton getInstance() { if (singleton ==  null) { synchronized (Singleton.class) { if (singleton == null) {                     singleton = new Singleton(); } } } return singleton; } } 

使用volatile关键字

上面双重校验锁可能会出现如下线程问题：
在 Singleton 构造函数体执行之前，变量 instance 可能成为非 null 的，即赋值语句在对象实例化之前调用，此时别的线程得到的是一个还会初始化的对象， 也就是 一个线程走到3正在初始化时被挂起，另一个线程走到0，发现instance不为null，就直接返回一个没有初始化完全的对象!
所以为了避免这种情况发生，我们给instance加上volatile关键字，利用它禁止指令重排序的功能，给写操作添加一个内存屏障。即在完全的初始化完一个对象前，不会调用读操作。

public class Singleton { private volatile static Singleton singleton; private Singleton() {} public static Singleton getInstance() { if (singleton ==  null) { synchronized (Singleton.class) { if (singleton == null) {                     singleton = new Singleton(); } } } return singleton; } } 

静态内部类登记

和饿汉式同样，使用ClassLoader机制来保证了初始化instance只有一个线程。而和饿汉式不一样的地方在于，使用了Lazy初始化，只有在主动调用getInstance方法时，才会实例化对象。

/**  * 懒汉式单例模式（线程不安全）  * */ public class Singleton { private static class SingletonHolder { private static final Singleton INSTANCE = new Singleton(); } private Singleton() {} public static Singleton getInstance() { return SingletonHolder.INSTANCE; } } 

枚举

采用单例模式的最佳方法，简介、自动支持序列化机制，而且避免了线程同步问题。不过目前很少被使用。

public enum  Singleton {     INSTANCE; public void whateverMethod() {} } 

使用ThreadLocal实现单例模式（线程安全）

ThreadLocal为每个线程提供一个独立的变量副本，从而隔离了多个线程对数据的访问冲突。

/**  * 使用ThreadLocal实现单例模式（线程安全）  * */ public class Singleton { private static final ThreadLocal<Singleton> tlSingleton = new ThreadLocal<Singleton>() { @Override protected Singleton initialValue() { return new Singleton(); } }; private Singleton(){} public static Singleton getInstance() { return tlSingleton.get(); } } 

使用CAS锁实现

import java.util.concurrent.atomic.AtomicReference; /**  * CAS  * */ public class Singleton { private static final AtomicReference<Singleton> INSTANCE = new AtomicReference<>(); private Singleton(){} public static Singleton getInstance() { for (;;) {             Singleton current = INSTANCE.get(); if (current != null) { return current; }             current = new Singleton(); if (INSTANCE.compareAndSet(null , current)) { return current; } } } }