不使用synchronized和lock，如何实现一个线程安全的单例？

灰太狼 2021-11-08 23:16 110阅读 0赞

阅读：  
AtomicReference源码解析和使用：  
[https://blog.csdn.net/Liu\_yunzhao/article/details/78484456][https_blog.csdn.net_Liu_yunzhao_article_details_78484456]

#### 如何使一个不安全的对象变成安全对象 除了lock和synchronized之外？ ####

如果不那么吹毛求疵的话，可以使用枚举、静态内部类以及饿汉模式来实现单例模式。见：[不使用synchronized和lock，如何实现一个线程安全的单例？][synchronized_lock]  
但是，上面这几种方法其实底层也都用到了`synchronized`，那么有没有什么办法可以不使用`synchronized`和`lock`，如何实现一个线程安全的单例？

答案是有的，那就是`CAS`。关于`CAS`，我博客中专门有一篇文章介绍过他，很多乐观锁都是基于`CAS`实现的。这里简单介绍一下，详细内容见 [乐观锁的一种实现方式——CAS][CAS]

> CAS是项乐观锁技术，当多个线程尝试使用CAS同时更新同一个变量时，只有其中一个线程能更新变量的值，而其它线程都失败，失败的线程并不会被挂起，而是被告知这次竞争中失败，并可以再次尝试。

在JDK1.5 中新增`java.util.concurrent`(J.U.C)就是建立在CAS之上的。相对于对于`synchronized`这种阻塞算法，CAS是非阻塞算法的一种常见实现。所以J.U.C在性能上有了很大的提升。

借助CAS（AtomicReference）实现单例模式：

public class Singleton {
        private static final AtomicReference<Singleton> INSTANCE = new AtomicReference<Singleton>(); 
     
        private Singleton() {}
     
        public static Singleton getInstance() {
            for (;;) {
                Singleton singleton = INSTANCE.get();
                if (null != singleton) {
                    return singleton;
                }
     
                singleton = new Singleton();
                if (INSTANCE.compareAndSet(null, singleton)) {
                    return singleton;
                }
            }
        }
    }

用CAS的好处在于不需要使用传统的锁机制来保证线程安全,CAS是一种基于忙等待的算法,依赖底层硬件的实现,相对于锁它没有线程切换和阻塞的额外消耗,可以支持较大的并行度。  
CAS的一个重要缺点在于如果忙等待一直执行不成功(一直在死循环中),会对CPU造成较大的执行开销。

[https_blog.csdn.net_Liu_yunzhao_article_details_78484456]: https://blog.csdn.net/Liu_yunzhao/article/details/78484456
[synchronized_lock]: http://www.hollischuang.com/archives/1860
[CAS]: http://www.hollischuang.com/archives/1537