深入理解线程安全的单例模式

末蓝、 2023-02-14 03:01 1阅读 0赞

1、单例模式是一种常用的设计模式，定义该对象的类只能允许一个实例存在。

为什么需要单例模式？在有的时候，系统需要全局唯一的对象，例如系统时间、某些统一配置数据，

只有单例模式才能正常的管理和应用这些数据；

2、常见的创建单例模式的写法，先私有构造器，然后提供 public static getInstance()方法 返回该对象实例，

例如java.util.Calendar 中的日期时间类：

Calendar now = Calendar.getInstance();

还有Runtime类的 getRunTime()方法（这里命名就不是getInstance()方法了）：

public class Runtime {
        private static Runtime currentRuntime = new Runtime();
    
        /**
         * Returns the runtime object associated with the current Java application.
         * Most of the methods of class <code>Runtime</code> are instance
         * methods and must be invoked with respect to the current runtime object.
         *
         * @return  the <code>Runtime</code> object associated with the current
         *          Java application.
         */
        public static Runtime getRuntime() {
            return currentRuntime;
        }
    
        /** Don't let anyone else instantiate this class */
        private Runtime() {}
    }

3、那么哪些单例模式才是线程安全的呢？

在现在的大多多线程并发环境中，我们需要考虑到线程安全的获取单例模式做法；

先来看一下饿汉模式Singleton.getInstance()，其实上面的Runtime.getRunTime()也是饿汉模式，这种是线程安全的，哪怕有多个线程同时执行Singleton.getInstance()时，其实在调用这个方法之前，发生并发之前，JVM虚拟机已经为我们创建好了这个单例对象，类在整个生命周期中只会被加载一次，所以是线程安全的

（类加载初始化的时候，先执行静态变量，这一句：private final static Singleton INSTANCE = new Singleton();

再执行静态代码块如果有静态代码块，然后再执行构造方法创建对象，如果想了解类初始化时的执行顺序，可以看看这篇博客：

[https://www.baidu.com/link?url=nw4zhbDHKVVMApmBoizOwGgQ2-u5ANAgtlI1Y3S9r07I05oKoiscckDWhnXVqv27eKc0BqLxIEVXuWQHZG\_\_ndDJC3Z6KDwJiTwnTQt3NR7&wd=&eqid=df70c112001cfcb4000000035ed3b2c3][https_www.baidu.com_link_url_nw4zhbDHKVVMApmBoizOwGgQ2-u5ANAgtlI1Y3S9r07I05oKoiscckDWhnXVqv27eKc0BqLxIEVXuWQHZG_ndDJC3Z6KDwJiTwnTQt3NR7_wd_eqid_df70c112001cfcb4000000035ed3b2c3]）：

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

4、饿汉模式的写法保证了线程安全，但是这样也有他的缺点，如果这个对象从头到尾一直没有用到，那么就会一直占用内存空间，引起不必要的浪费；

那么有没有延迟加载方式的单例模式呢？如下懒汉模式：

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

5、上面写法是线程不安全的，所以有时候说加上**synchronized** 关键字，保证了线程安全，但是效率很低，目前每获取一次都要同步等待，所以不推荐：

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

6、于是又诞生了一种双重检查模式，这种方式是线程安全的吗？

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;
        }
    }

（第八行这一代码 instance=new Singleton()）创建了一个对象。这一 行代码可以分解为如下的3行伪代码。

memory = allocate(); // 1：分配对象的内存空间

ctorInstance(memory); // 2：初始化对象

instance = memory; // 3：设置instance指向刚分配的内存地址

上面3行伪代码中的2和3之间，可能会被重排序（在一些JIT编译器上，这种重排序是真实 发生的，2和3之间重排序之后的执行时序如 下。

memory = allocate(); // 1：分配对象的内存空间

instance = memory; // 3：设置instance指向刚分配的内存地址 // 注意，此时对象还没有被初始化！

ctorInstance(memory); // 2：初始化对象

所以这样，在多个线程访问情况下，可能造成创建了不只一个对象，达不到线程安全的效果；

解决方案：在第二行代码上加一个 **volatile** 关键字, private static **volatile** Singleton singleton，达到禁止指令重排序，线程安全效果；这一点再具体的分析，在读《Java并发编程的艺术》一书里面，讲的很清楚，推荐看一下：

[《Java并发编程的艺术》 读书笔记 之 Java内存模型（八）双重检查锁定与延迟初始化][Java_ _ _ Java]

7、除了用双重模式实现延迟加载单例模式以外，还有一种，静态内部类的方式实现：

public class Singleton {
    
    	private Singleton() {
    	}
    
    	private static class SingletonInstance {
    		private static final Singleton INSTANCE = new Singleton();
    	}
    
    	public static Singleton getInstance() {
    		return SingletonInstance.INSTANCE;
    	}
    }

采用了类装载的机制来保证初始化实例时只有一个线程，类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的；

8、还有另外一种新方式，来实现单例模式，枚举类：

在读《Effective Java》的时候，提到有一种单例模式：

public class Singleton {
    
      private Singleton(){ }
    
      //定义一个静态枚举类
      static enum SingletonEnum{
        //创建一个枚举对象，该对象为单例
        INSTANCE;
        private Singleton instance;
    
        private SingletonEnum(){
          instance=new Singleton();
        }
        public Singleton getInstnceEnum(){
          return instance;
        }
      }
    
      //对外的静态方法，该方法获取单例对象
      public static Singleton getInstance(){
        return SingletonEnum.INSTANCE.getInstnceEnum();
      }
    }

原因有下二：
    1、反射的时候可以创建多个单例对象：
    《Effective java》中只简单的提了几句话：
    享有特权的客户端可以借助AccessibleObject.setAccessible方法，
    通过反射机制调用私有构造器。
    如果需要抵御这种攻击，可以修改构造器，
    让它在被要求创建第二个实例的时候抛出异常。
    
    2、序列化反序列化的时候，也会创建多出来的对象：
    如果避免这种情况创建多个对象，需要在声明中加上
    " implements Serializable" ，
    并且把实例域声明为transient变量，
    此外还需要提供一个readResolve()方法

看起来有点和静态内部类实现单例的方式相似，但是用这种方式，可以防止反序列化和反射的时重新创建新的对象，所以作者也说这是最佳实现单例的方式：

书中原文截图如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xlanVzdGRvaXQ_size_16_color_FFFFFF_t_70][]

[https_www.baidu.com_link_url_nw4zhbDHKVVMApmBoizOwGgQ2-u5ANAgtlI1Y3S9r07I05oKoiscckDWhnXVqv27eKc0BqLxIEVXuWQHZG_ndDJC3Z6KDwJiTwnTQt3NR7_wd_eqid_df70c112001cfcb4000000035ed3b2c3]: https://www.baidu.com/link?url=nw4zhbDHKVVMApmBoizOwGgQ2-u5ANAgtlI1Y3S9r07I05oKoiscckDWhnXVqv27eKc0BqLxIEVXuWQHZG__ndDJC3Z6KDwJiTwnTQt3NR7&wd=&eqid=df70c112001cfcb4000000035ed3b2c3
[Java_ _ _ Java]: https://blog.csdn.net/lejustdoit/article/details/97260059
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xlanVzdGRvaXQ_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200531224233348.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xlanVzdGRvaXQ=,size_16,color_FFFFFF,t_70