你写的单例是线程安全的吗？

在日常的编码中，我们可能见过各种各样的单例模式，那么今天通过这篇文章来和大家探讨下单例模式的线程安全性问题，看看我们平时所写的单例模式是不是基于线程安全的。

并发编程的三大要素是：原子性(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 Synchronize 和 Lock 的区别与用法
  

• 【附视频】后台管理框架guns讲解和环境搭建

• Redis分布式锁-乐观锁的实现，以秒杀系统为例