《实战高并发程序设计》读书笔记-探讨单例模式

妖狐艹你老母 2021-09-18 07:36 336阅读 0赞

# 模式 #

# 探讨单例模式 #

单例模式是设计模式中使用最为普遍的模式之一。它是一种对象创建模式，用于产生一个对象的具体实例，它可以确保系统中一个类只产生一个实例。

--------------------

在Java中，这样的行为能带来两大好处：

*  对于频繁使用的对象，可以省略new操作花费的时间，这对于那些重量级对象而言，是非常可观的一笔系统开销；
 *  由于new操作的次数减少，因而对系统内存的使用频率也会降低，这将减轻GC压力，缩短GC停顿时间。

--------------------

严格来说，单例模式与并行没有直接的关系。这里我希望讨论这个模式，是因为它实在是太常见了。并且，我们不可避免的，会在多线程环境中使用它们。并且，系统中使用单例的地方可能非常频繁，因此，我们非常迫切需要一种高效的单例实现。  
  下面给出了一个单例的实现，这个实现是非常简单的，但无疑是一个正确并且良好的实现。

1 public class Singleton {
    2     private Singleton(){
    3         System.out.println("Singleton is create");
    4     }
    5     private static Singleton instance = new Singleton();
    6     public static Singleton getInstance() {
    7         return instance;
    8     }
    9 }

使用以上方式创建单例有几点必须特别注意。

*  因为我们要保证系统中不会有人意外创建多余的实例，因此，我们把Singleton的构造函数设置为private。这点非常重要，这就警告所有的开发人员，不能随便创建这个类的实例，从而有效避免该类被错误的创建。
 *  instance对象必须是private并且static的。如果不是private，那么instance的安全性无法得到保证。一个小小的意外就可能使得instance变成null。
 *  其次，因为工厂方法getInstance()必须是static的，因此对应的instance也必须是static。

这个单例的性能是非常好的，因为getInstance()方法只是简单地返回instance，并没有任何锁操作，因此它在并行程序中，会有良好的表现。

## 明显不足：对象第一次实例化的时机会失控 ##

就是Singleton构造函数，或者说Singleton实例在什么时候创建是不受控制的。

对于静态成员instance，它会在类第一次初始化的时候被创建。这个时刻并不一定是getInstance()方法第一次被调用的时候。

即：对象实例为static，会随着类的初始化而创建，类的初始化只有一次，对象实例化也就只有一次，如果对象中有其他可以对外暴露访问的静态属性或方法，一旦被引用，均会导致对象实例化，这样对象第一次实例化的时机就不受控了，getInstance()方法第一次被调用的之前就已经存在对象实例了。

比如，如果你的单例像是这样的：

public class Singleton {
        public static int STATUS=1;
        private Singleton(){
            System.out.println("Singleton is create");
        }
        private static Singleton instance = new Singleton();
        public static Singleton getInstance() {
            return instance;
        }
    }

注意，这个单例还包含一个表示状态的静态成员STATUS。此时，在相同任何地方引用这个STATUS都会导致instance实例被创建（任何对Singleton方法或者字段的引用，都会导致类初始化，并创建instance实例，但是类初始化只有一次，因此instance实例永远只会被创建一次）。比如：

System.out.println(Singleton.STATUS);

上述println会打印出：

Singleton is create
    1

可以看到，即使系统没有要求创建单例，new Singleton()也会被调用。  
如果大家觉得这个小小的不足并不重要，我认为这种单例模式是一种不错的选择。它容易实现，代码易读而且性能优越。  
但如果你想精确控制instance的创建时间，那么这种方式就不太友善了。

我们需要寻找一种新的方法，一种支持延迟加载的策略，它只会在instance被第一次使用时，创建对象。具体实现如下：

01 public class LazySingleton {
    02     private LazySingleton() {
    03         System.out.println("LazySingleton is create");
    04     }
    05     private static LazySingleton instance = null;
    06     public static synchronized LazySingleton getInstance() {
    07         if (instance == null)
    08             instance = new LazySingleton();
    09         return instance;
    10     }
    11 }

这个LazySingleton的核心思想如下：

*  最初，我们并不需要实例化instance，而当getInstance()方法被第一次调用时，创建单例对象。
 *  为了防止对象被多次创建，我们不得不使用synchronized进行方法同步。
    
     *  这种实现的好处是，充分利用了延迟加载，只在真正需要时创建对象。但坏处也很明显，并发环境下加锁，竞争激烈的场合对性能可能产生一定的影响。

但总体上，这是一个非常易于实现和理解的方法。

此外，还有一种被称为双重检查模式的方法可以用于创建单例。但我并不打算在这里介绍它，因为这是一种非常丑陋、复杂的方法，甚至在低版本的JDK中都不能保证正确性。因此，绝不推荐大家使用。如果大家阅读到相关文档，我也强烈建议大家不要在这种方法上花费太多时间。

在上述介绍的两种单例实现中，可以说是各有千秋。有没有一种方法可以结合二者之优势呢？答案是肯定的：

01 public class StaticSingleton {
    02     private StaticSingleton(){
    03         System.out.println("StaticSingleton is create");
    04     }
    05     private static class SingletonHolder {  //利用虚拟机的类初始化机制创建单例
    06         private static StaticSingleton instance = new StaticSingleton();
    07     }
    08     public static StaticSingleton getInstance() {
    09         return SingletonHolder.instance;
    10     }
    11 }

上述代码实现了一个单例，并且同时拥有前两种方式的有点。

*  首先getInstance()方法中没有锁，这使得在高并发环境下性能优越。
 *  其次，只有在getInstance()方法被第一次调用时，StaticSingleton的实例才会被创建。

因为这种方法巧妙地使用了内部类和类的初始化方式。内部类SingletonHolder被申明为private，这使得我们不可能在外部访问并初始化它。而我们只可能在getInstance()内部对SingletonHolder类进行初始化，利用虚拟机的类初始化机制创建单例。