设计模式 -- "单例"


一、概述

1.1 什么是单例?

这种模式涉及到一个单一的类,该类负责创建自己的对象,同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式,可以直接访问,不需要实例化该类的对象

我们需要注意:

                  ✵   单例类:只能有一个实例(有且唯一)。
                  ✵   单例类:必须自己创建自己的唯一实例(自己创建自己)。
                  ✵   单例类:必须给所有其他对象提供这一实例(提供给别人调用自己的方法)。

1.2 举个例子

我们看个简单的 “单例设计” 的 Demo,先创建一个 Singleton(单例) 类:SingleObject.java

public class SingleObject {

   //创建 SingleObject 的一个对象
   private static SingleObject instance = new SingleObject();    --> 1、有且仅有一个实力;2、自己创建自己的实例

   // 让构造函数为 private,这样该类就无法被实例化
   private SingleObject(){}

   // 获取唯一可用的对象
   public static SingleObject getInstance(){    --> 3、为其他对象提供自己的实例
      return instance;
   }

   public void showMessage(){
      System.out.println("Hello World!");
   }
}

然后我们再创建一个类 SingletonPatternDemo.java 去获取 SingleObject 的实例:

public class SingletonPatternDemo {
   public static void main(String[] args) {

      // 不合法的构造函数,编译时错误:构造函数 SingleObject() 是不可见的
      //SingleObject object = new SingleObject();

      // 获取唯一可用的对象
      SingleObject object = SingleObject.getInstance();

      // 显示消息
      object.showMessage();
   }
}

我们看下执行结果:

Hello World!


二、实现方式

2.1 基本版:饿汉式

代码范例

    public class Singleton {  

        private static Singleton instance = new Singleton();    // 类加载时就初始化
        private Singleton (){}  

        public static Singleton getInstance() {  
            return instance;  
        }  
    }

方法说明

这种方式比较常见,典型的 “饿汉式” 写法。

是否多线程安全
实现难度
优点 没有加锁,执行效率会提高
缺点 类加载时就初始化,浪费内存

2.2 改进版:懒汉式 - 线程不安全

代码范例

    public class Singleton {  

        private static Singleton instance;    // 类加载时不作初始化
        private Singleton (){}  

        public static Singleton getInstance() {  
            if (instance == null) {  
                instance = new Singleton();  
            }  
            return instance;  
        }  
    }

方法说明

这种方式是大多数面试者的写法,也是教科书上的标配,但这段代码却存在一个致命的问题:当多个线程并行调用 getInstance() 的时候,就会创建多个实例。

是否多线程安全
实现难度
优点 第一次调用才初始化,避免内存浪费
缺点 当多个线程并行调用 getInstance() 的时候,就会创建多个实例。

2.3 改进版:懒汉式 - 线程安全

代码范例

    public class Singleton {  

        private static Singleton instance;  
        private Singleton (){}  

        public static synchronized Singleton getInstance() {    // 加锁
            if (instance == null) {  
                instance = new Singleton();  
            }  
            return instance;  
        }  
    }

方法说明

既然要线程安全,那就如上所述进行 “加锁” 处理!

是否多线程安全
实现难度
优点 第一次调用才初始化,避免内存浪费
缺点 必须加锁 synchronized 才能保证单例,但加锁会影响效率(加锁操作也是耗时的)

2.4 改进版:双重校验锁

代码范例

    public class Singleton {  

        private static Singleton instance;  
        private Singleton (){}  

        public static Singleton getSingleton() {  
            if (instance == null) {  
                synchronized (Singleton.class) {  
                    if (instance == null) {  
                        instance = new Singleton();  
                    }  
                }  
            }  
            return instance;  
        }  
    }

方法说明

为什么需要进行 2 次判断是否为空呢?

第一次判断是为了避免不必要的同步,第二次判断是确保在此之前没有其他进程进入到 synchronized 块创建了新实例。

这段代码看起来很完美,很可惜,它还是有隐患!

主要在于 instance = new Singleton() 这句,这并非是一个原子操作,事实上在 JVM 中这句话大概做了下面 3 件事情:

      ✵ 1、给 instance 分配内存
      ✵ 2、调用 Singleton 的构造函数来初始化成员变量
      ✵ 3、将 instance 对象指向分配的内存空间(执行完这步 instance 就为非 null 了)

但是在 JVM 的即时编译器中存在指令重排序的优化。也就是说上面的第二步和第三步的顺序是不能保证的,最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是后者,则在 3 执行完毕、2 未执行之前,被线程二抢占了,这时 instance 已经是非 null 了(但却没有初始化),所以线程二会直接返回 instance,然后使用,最后顺理成章地报错。

2.5 改进版:双检锁(volatile)

代码范例

    public class Singleton {  

        private volatile static Singleton instance;  
        private Singleton (){}  

        public static Singleton getSingleton() {  
            if (instance == null) {  
                synchronized (Singleton.class) {  
                    if (instance == null) {  
                        instance = new Singleton();  
                    }  
                }  
            }  
            return instance;  
        }  
    }

方法说明

有些人认为使用 volatile 的原因是可见性,也就是可以保证线程在本地不会存有 instance 的副本,每次都是去主内存中读取。但其实是不对的。

使用 volatile 的主要原因是其另一个特性:禁止指令重排序优化

也就是说,在 volatile 变量的赋值操作后面会有一个内存屏障(生成的汇编代码上),读操作不会被重排序到内存屏障之前。比如上面的例子,取操作必须在执行完 1-2-3 之后或者 1-3-2 之后,不存在执行到 1-3 然后取到值的情况。从「先行发生原则」的角度理解的话,就是对于一个 volatile 变量的写操作都先行发生于后面对这个变量的读操作(这里的“后面”是时间上的先后顺序)。

但是特别注意在 Java 5 以前的版本使用了 volatile 的双检锁还是有问题的。其原因是 Java 5 以前的 JMM (Java 内存模型)是存在缺陷的,即使将变量声明成 volatile 也不能完全避免重排序,主要是 volatile 变量前后的代码仍然存在重排序问题。这个 volatile 屏蔽重排序的问题在 Java 5 中才得以修复,所以在这之后才可以放心使用 volatile。

那么,有没有一种既有懒加载,又保证了线程安全,还简单的方法呢?

当然有,静态内部类就是这么一种我们想要的方法。我们完全可以把 Singleton 实例放在一个静态内部类中,这样就避免了静态实例在 Singleton 类加载的时候就创建对象,并且由于静态内部类只会被加载一次,所以这种写法也是线程安全的。

2.6 终极版:静态内部类

代码范例

    public class Singleton {  

        private static class SingletonHolder {  
            private static final Singleton INSTANCE = new Singleton();  
        }  

        private Singleton (){}  

        public static final Singleton getInstance() {  
            return SingletonHolder.INSTANCE;  
        }  
}

方法说明

这是比较推荐的解法,这种写法用 JVM 本身的机制保证了线程安全的问题,同时读取实例的时候也不会进行同步,没什么性能缺陷,还不依赖 JDK 版本。

2.7 传说版:枚举

代码范例

    public enum Singleton {  
        INSTANCE;  
    }

方法说明

这是从 Java 1.5 发行版本后就可以实用的单例方法,我们可以通过 Singleton.INSTANCE 来访问实例,这比调用 getInstance() 方法简单多了。

创建枚举默认就是线程安全的,所以不需要担心 double checked locking(双重校验锁),而且还能防止反序列化导致重新创建新的对象。