在日常的编码中，我们可能见过各种各样的单例模式，那么今天通过这篇文章来和大家探讨下单例模式的线程安全性问题，看看我们平时所写的单例模式是不是基于线程安全的。
并发编程的三大要素是：原子性(Atomicity)、可见性(Visibility)、有序性（Ordering）
原子性：一个操作或多个操作要么全部执行完成且执行过程不被中断，要么就不执行。
可见性：当多个线程同时访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。
有序性：程序执行的顺序按照代码的先后顺序执行。
饿汉模式
public class Singleton { private static Singleton instance = new Singleton(); private Singleton() { } public static Singleton getInstance() { return instance; } }
结论：线程安全、绝对单例
缺点：假设有多个实例或静态方式时，没用到的实例也初始化了，浪费内存
懒汉模式
public class Singleton { private static Singleton instance = null; private Singleton() { } public static Singleton getInstance() { if (null == instance) {//1 instance = new Singleton(); } return instance; } }
结论：非线程安全，当多个线程执行到1处会产生多个实例
加方法锁
public class Singleton { private static Singleton instance = null; private Singleton() { } public static synchronized Singleton getInstance() { if (null == instance) { instance = new Singleton(); } return instance; } }
结论：线程安全，绝对单例
synchronized代码块锁+双重检查 public class Singleton { private static Singleton instance = null; private Singleton() { } public static Singleton getInstance() { if (null == instance) { synchronized (Singleton.class) { if (null == instance) { //1 instance = new Singleton(); } } } return instance; } }
分析：大部分情况下是线程安全的，但是在代码块注释1处，如果发生指令重排序，则会出现线程不安全，如
instance = new Singleton(); if (null == instance) { }
那么如何解决这个问题呢？加valotile关键字即可
public class Singleton { private static volatile Singleton instance = null; private Singleton() { } public static Singleton getInstance() { if (null == instance) { synchronized (Singleton.class) { if (null == instance) { //1 instance = new Singleton(); } } } return instance; } }
valotile作用：内存可见性、禁止指令重排序
结论：线程安全、绝对单例
枚举
public enum Singleton { INSTANCE; private Singleton() {} }
结论：线程安全、绝对单例，因为创建枚举默认就是线程安全的。
静态内部类
public class SingletonPattern { private SingletonPattern() { } private static class SingletonPatternHolder { private static final SingletonPattern singletonPattern = new SingletonPattern(); } public static SingletonPattern getInstance() { return SingletonPatternHolder.singletonPattern; } }
在这个例子中内部类 SingletonPatterHolder 的静态变量 singletonPattern，这个变量是我们需要的那个单例，即外部类 SingletonPattern 的对象，就是那个我们需要的唯一的对象。
当我们调用 SingletonPattern.getInstance() 时，内部类 SingletonPatternHolder 才会初始化，静态变量 singletonPattern 被创建出来
结论：线程安全，绝对单例
上面这么多例子想必大家收获不少，下面再举一个例子，大家看看是不是线程安全的绝对单例
public class Singleton { private static Singleton singleton = null; private static Lock lock = new ReentrantLock(); private Singleton(){} public static Singleton getInstance(){ if(singleton == null){ lock.lock(); if(singleton == null){ singleton = new Singleton(); } lock.unlock(); } return singleton; } }
作者： 刘志鹏 ，公众号：JAVA葵花宝典
