单例模式(Singleton Pattern)

JFS_Study

已于 2022-05-30 17:24:33 修改

阅读量279

点赞数

分类专栏： DesignPattern 文章标签：单例模式 java 开发语言

于 2022-01-18 16:09:29 首次发布

本文链接：https://blog.csdn.net/ChineseSoftware/article/details/122562012

版权

DesignPattern 专栏收录该内容

12 篇文章 1 订阅

订阅专栏

一、简述

单例模式是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一对象的方式，可以直接访问，不需要实例化该类的对象。即两私一公：①私有的构造函数②私有静态实例属性③公共的获取实例的静态方法。

1️⃣注意

单例类只能有一个实例。
单例类必须自己创建自己的唯一实例。
单例类必须给所有其他对象提供这一实例。

2️⃣资源加载和性能

饿汉式在类创建的同时就实例化一个静态对象出来，无论会不会用到，都会占据一定的内存。相应的，在第一次调用时速度更快，因为其资源已经初始化完成。

懒汉式，会延迟加载，在初次使用该单例时才会实例化对象出来。首次调用时要做初始化，如果要做的工作比较多，性能会有所延迟，之后就和饿汉式一样了。

主要解决：一个全局使用的类频繁地创建与销毁。
何时使用：当想控制实例数目，节省系统资源的时候。
如何解决：判断系统是否已经有这个单例，有则返回，没有则创建。
关键代码：构造函数是私有的。

3️⃣应用实例

一个男人只能有一个妻子。
Windows 是多进程多线程的，难免会出现多个进程或线程同时操作一个文件的现象，所以所有文件的处理必须通过唯一的实例来进行。
一些设备管理器常常设计为单例模式。比如一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件。

4️⃣优点

在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例(比如管理学院首页页面缓存)。
避免对资源的多重占用(比如写文件操作)。

5️⃣缺点

没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

6️⃣使用场景

要求生产唯一序列号。
WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
创建的一个对象需要消耗的资源过多，比如I/O与数据库的连接等。

二、饿汉式—线程安全

饿汉就是类一旦加载，就把单例初始化完成，保证 getInstance 的时候，单例已经存在。

描述：这种方式比较常用，但容易产生垃圾对象。
优点：没有加锁，执行效率会提高。
缺点：类加载时就初始化，浪费内存。
它基于 classloder 机制避免了多线程的同步问题。不过，instance 在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance 方法，但是也不能确定有其他的方式(或者其他的静态方法)导致类装载，这时候初始化 instance 显然没有达到 lazy loading 的效果。

public class EagerSingleton() {
    //持有自己的引用
    private static final EagerSingleton m_instatnce = new EagerSingleton();
    //构造器私有化，不能在类的外部随意创建对象
    private EagerSingleton() {
    }
    //提供一个全局的访问点来获得这个“唯一”的对象
    public static EagerSingleton getInstance() {
        System.out.println("加载饿汉式....");
        return m_instatnce;
    }
}

静态代码块实现：

public class EagerSingleton{
    private static EagerSingletoninstance;
    static {
        m_instatnce = new EagerSingleton();
    }
    private EagerSingleton() {}
    public static EagerSingleton getInstance() {
        return m_instatnce;
    }
}

这种方式和上面的方式其实类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。优缺点和上面是一样的。

三、懒汉式—非线程安全

Lazy 初始化。
描述：最基本的实现方式，最大的问题就是不支持多线程。因为没有加 synchronized 锁，所以严格意义上它并不算单例模式。
这种方式 lazy loading 很明显，不要求线程安全，在多线程不能正常工作。

public class LazySingleton(){
  private static LazySingleton instatnce=null;
  // 构造器私有化,不能在类的外部随意创建对象
  private LazySingleton(){}
  // 提供一个全局的访问点来获得这个"唯一"的对象
  public static LazySingleton getInstance(){      
       if(instatnce == null){               //1：读取instance的值
          instatnce = new LazySingleton();   //2: 实例化instance   
        }            
        return instatnce;        
    }
}

懒汉比较懒，只有当调用 getInstance 的时候，才会去初始化这个单例。

四、懒汉非线程安全原因(两点)

对于以上代码注释部分，如果此时有两个线程，线程甲执行到 1 处读取了 instance 为 null，然后 cpu 就被线程乙抢去了，此时线程甲还没有对 instance 进行实例化。因此，线程乙读取 instance 时仍然为 null，于是它对 instance 进行实例化了。然后，cpu 时间片轮到线程甲。此时，线程甲已经读取了 instance 的值并且认为它为 null，再次对 instance 进行实例化。所以，线程甲和线程乙返回的不是同一个实例。

如何解决呢？

在方法前面加 synchronized 修饰。这样肯定不会再有线程安全问题。

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

这种解决方式有个问题：假如有 100 个线程同时执行，那么每次去执行 getInstance 方法时都要先获得锁再去执行方法体。如果没有锁就要等待，耗时长，像是变成了串行处理。
特点：
性能不高，同步范围太大。在实例化后，获取实例仍然是同步的，效率太低，需要缩小同步的范围。

加同步代码块，减少锁的颗粒大小。判断 instance 是否为 null 是读的操作，不存在线程安全问题。因此，只需要对创建实例的代码进行同步代码块的处理，也就是所谓的对可能出现线程安全的代码进行同步代码块的处理。

public class LazySingleton(){
    private static LazySingleton instatnce=null;
    private LazySingleton(){}
    public static LazySingleton getInstance(){      
         if(instatnce == null){ 
            synchronized (LazySingleton.class){       
               instatnce = new LazySingleton();      
            }  
          }          
          return instatnce;        
      }
}

这样处理就没有问题了吗？同样的原理，线程甲读取 instance 值为 null，此时 cpu 被线程乙抢去了，线程乙判断 instance 值也为 null，于是它开始执行同步代码块，对 instance 进行实例化。此时，线程甲获得 cpu，由于线程甲之前已经判断 instance 值为 null，于是开始执行它后面的同步代码块。它也会去对 instance 进行实例化。这样就导致了还是会创建两个不一样的实例。
特点：
缩小同步范围，来提高性能，但是仍然存在多次执行instance=new Singleton()的可能，由此引出 double check。

如何解决上面的问题？

很简单，在同步代码块中 instance 实例化之前进行判断，如果 instance 为 null，才对其进行实例化。这样，就能保证 instance 只会实例化一次了。也就是所谓的双重检查加锁机制。

再次分析上面的场景：
线程甲读取 instance 值为 null，此时 cpu 被线程乙抢去了，线程乙再来判断 instance 值为 null。于是，它开始执行同步代码块，对 instance 进行了实例化。这时线程甲获得 cpu 执行权，当线程甲去执行同步代码块时，它再去判断 instance 的值，由于线程乙执行完后已经将这个共享资源 instance 实例化了，所以 instance 不再为 null，所以，线程甲就不会再次实行实例化代码了。

public class LazySingleton() {
    private LazySingleton(){}
    private static LazySingleton instatnce=null;
    public static LazySingleton getInstance(){
        if(instatnce== null) {
            synchronized (LazySingleton.class){
                if (instatnce == null){
                    instatnce = new LazySingleton();
                }
            }
        }
        return instatnce;
    }
}

双重检查加锁并不表示一定没有线程安全问题了。因为，Java 内存模型(Java Memory Model)并不限制处理器重排序。instatnce = new LazySingleton()并不是原子语句，其实可以分为下面的步骤：

申请一块内存空间；
在这块空间里实例化对象；
instatnce 的引用指向这块空间地址(instatnce 指向分配的内存空间后就不为 null 了)。
【由此可理解，Java 中 new 操作是不具有原子性的】

指令重排序存在的问题是：
对于以上步骤，指令重排序很有可能不是按上面【1、2、3】步骤依次执行的。比如，先执行 1 申请一块内存空间，然后执行 3，instatnce 的引用去指向刚刚申请的内存空间地址。那么，当它再去执行 2，判断 instatnce 时，由于 instatnce 已经指向了某一地址，它就不会再为 null 了，因此，也就不会实例化对象了。这就是所谓的指令重排序安全问题。那么，如何解决这个问题呢？

加上关键字 volatile，因为 volatile 可以禁止指令重排序。volatile 可以保证【1、2、3】的执行顺序，没执行完 1、2 就肯定不会执行 3，也就是没有执行完 1、2，instance 一直为空。这样就可以保证 3(instance 赋值操作)是最后一步完成，这样就不会出现 instance 在对象没有初始化时就不为 null 的情况了。这样也就实现了正确的单例模式。具体代码如下：

public class LazySingleton() {
    private LazySingleton(){}
    private static volatile LazySingleton instatnce=null;
    public static LazySingleton getInstance(){
        if(instatnce== null) {
            synchronized (LazySingleton.class){
                if (instatnce == null){
                    instatnce = new LazySingleton();
                }
            }
        }
        return instatnce;
    }
}

附：
1️⃣静态内部类懒汉模式

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

静态内部类在没有显示调用的时候是不会进行加载的，当执行了
return InstanceHolder.instance后才加载初始化，这样就实现了正确的单例模式。
2️⃣利用枚举的特性在 JVM 层保证绝对的单例

class EnumSingleton {
      //私有构造函数，防止new对象
      private EnumSingleton() {}
      public static EnmuSingleton getInstance() {
          return Singleton.INSTANCE.getSingleton();
      }
      //JVM层保证绝对单例
      private enum Singleton {
          INSTANCE;
          private EnumSingleton singleton;
          Singleton() {
                singleton = new EnumSingleton();
          }
          public EnumSingleton getSingleton() {
                  return singleton;
          }
      } 
}