设计模式详解之单例模式（二）

比眉伴天荒 2022-05-21 03:10 166阅读 0赞

前面说到了单例模式写法的分析，这篇文章打算写下单例模式的几种写法。

**第一种：懒汉式，线程不安全**

懒汉式实现了懒加载，也就是将对象的创建放在执行getInstance方法中，只有在调用该方法时才会创建对象，所以我们可以这么实现，首先按单例模式的写法写出一个类：

public class SingleObject {
     
       //创建 SingleObject 的一个对象
       private static SingleObject instance = new SingleObject();
     
       //让构造函数为 private，这样该类就不会被实例化
       private SingleObject(){}
     
       //获取唯一可用的对象
       public static SingleObject getInstance(){
          return instance;
       }
     
       public void showMessage(){
          System.out.println("Hello World!");
       }
    }

然后我们再对其进行相应的改写，因为是懒加载模式，所以在定义对象的时候不需要对对象进行实例化：

public class SingleObject {
     
       //定义 SingleObject 的一个对象，不进行实例化
       private static SingleObject instance = null;
     
       //让构造函数为 private，这样该类就不会被实例化
       private SingleObject(){}
     
       //进行判断，如果SingleObject已经被实例化过，则直接返回instance，如果没被实例化则先进行创建。
       public static SingleObject getInstance(){
          if(instance == null){
             instance = new SingleObject();
          }
          return instance;
       }
     
       public void showMessage(){
          System.out.println("Hello World!");
       }
    }

这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，所以严格意义上它并不算单例模式。

这种方式 lazy loading 很明显，不要求线程安全，在多线程不能正常工作。

** 第二种：懒汉式，线程安全**

这种方式就是在第一种方法上对getInstance方法用synchronized修饰：

public class SingleObject {
     
       //定义 SingleObject 的一个对象，不进行实例化
       private static SingleObject instance = null;
     
       //让构造函数为 private，这样该类就不会被实例化
       private SingleObject(){}
     
       //进行判断，如果SingleObject已经被实例化过，则直接返回instance，如果没被实例化则先进行创建。
       public static synchronized SingleObject getInstance(){
          if(instance == null){
             instance = new SingleObject();
          }
          return instance;
       }
     
       public void showMessage(){
          System.out.println("Hello World!");
       }
    }

这种方式具备很好的 lazy loading，能够在多线程中很好的工作，但是，效率很低，99% 情况下不需要同步。

**第三种：饿汉式**

所谓饿汉式我的理解上更觉得像“保姆式”，就是我先帮你的菜准备好，你要吃的时候拿，吃多少都可以的感觉，这种方式没有实现懒加载，是一种比较常用的方式，但是容易产生垃圾对象。

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

从实现方式上看，此方式在类加载时就进行了初始化，会比较浪费内存，但是呢，它基于 classloder 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance 方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 显然没有达到懒加载的效果。也就是说在实现了线程安全的同时，没有对其加锁，所以相比较懒汉式（线程安全）的实现方式执行效率上会提高不少。

**第四种：双检锁/双重校验锁（DCL，即double-checked locking）**

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

这种方式采用双锁机制，安全且在多线程情况下能保持高性能。如何实现线程安全的呢？首先我们来看，这里我们用volatile关键字修饰了singleton这个属性，就表示该singleton在线程中是“可见的”，如果某个线程对这个属性进行了操作，那么其他正在使用此资源的线程能够看到其改变，这里我们对其操作仅仅是对其实例化，也就是说如果实例化了该对象那么我们就不会调用其实例化方法，第一重判断，是进行该对象是否已经实例化过，再进行第二重判断时，对其加了synchronized锁锁了代码块，这个锁的作用是保证一个线程同步的过程，如果有一个线程在“排着队”，锁内部有个线程对其进行了实例化，则此时这个排队的线程就可以看见singleton的改变，而当其进入锁进行操作时，singleton存在实例了，所以就不会执行new操作，直接return，这样提高了效率的同时又保证了线程安全。

**第五种：登记/静态内部类**

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

这种方式能达到双检锁方式一样的功效，但实现更简单。对静态域使用延迟初始化，应使用这种方式而不是双检锁方式。这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用。

这种方式同样利用了类加载机制来保证初始化 instance 时只有一个线程，它跟第 3 种方式不同的是：第 3 种方式只要 Singleton 类被装载了，那么 instance 就会被实例化（没有达到懒加载的效果），而这种方式是 Singleton 类被装载了，instance 不一定被初始化。因为 SingletonHolder 类没有被主动使用，只有通过显式调用 getInstance 方法时，才会显式装载 SingletonHolder 类，从而实例化 instance。想象一下，如果实例化 instance 很消耗资源，所以想让它延迟加载，另外一方面，又不希望在 Singleton 类加载时就实例化，因为不能确保 Singleton 类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化 instance 显然是不合适的。这个时候，这种方式相比第 3 种方式就显得很合理。

**第六种：枚举**

public enum Singleton {  
        INSTANCE;  
        public void whateverMethod() {  
        }  
    }

这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。不过，由于 JDK1.5 之后才加入 enum 特性，用这种方式写不免让人感觉生疏，在实际工作中，也很少用。

**总结：**

一般情况下，不建议使用第 1 种和第 2 种懒汉方式，建议使用第 3 种饿汉方式。只有在要明确实现懒加载效果时，才会使用第 5 种登记方式。如果涉及到反序列化创建对象时，可以尝试使用第 6 种枚举方式。如果有其他特殊的需求，可以考虑使用第 4 种双检锁方式。