设计模式——单例模式

引言

  今天来谈谈设计模式中的单例模式,温故知新,以免生疏。

《设计模式——单例模式》

  软件设计领域的四位世界级大师Gang Of Four (GoF):Erich Gamma,Richard Helm,Ralph Johnson,John Vlissides四人合著了《Design Patterns – Elements of Reusable Object-Oriented Software》一书,(中文译名:《设计模式:可复用面向对象软件的基础》)。该书首次提到了软件开发中设计模式的概念,对面向对象软件设计产生了巨大影响。

  • 创建型模式

  单例模式属于创建型模式,那么这里就要简述一下创建型模式。顾名思义,就是创建对象的设计模式。频繁地使用基本对象创建方式(比如new操作)会使系统的耦合性变高,导致某些设计上的问题。创建型模式对类的实例化进行抽象,将对象的创建与对象的使用分离,隐藏了类的实例化过程。

  • 单例模式的由来

  在系统中,有一些对象其实只需要一个,例如线程池、缓存、注册表、日志对象、充当打印机显卡等设备驱动程序的对象。同时这些类比较庞大复杂,并且这些对象完全可以复用。若创建多个实例或频繁创建销毁实例对象,会导致程序行为异常、资源使用过量、或者不一致性的结果,这就有了单例模式。

  • 单例模式含义

    确保一个类只有一个实例,并提供该实例的全局访问点,后半句通俗点讲,就是向整个系统提供这个实例。

类的构成

  • 构造函数: private Singleton(){},私有。因为一个类只能有一个实例,不可被外部再次实例化,构造方法不可能是public,只能是private。保证了不能通过构造器进行创建实例对象。

  • (成员)变量:private static Singleton instance,私有,静态变量。由于类中仅有一个实例,属于当前类的静态变量,外部无法直接访问。

  • 方法:public static Singleton getInstance(){},公有,静态方法。要向整个系统提供该单例,就要创建一个公有的静态方法向外界提供当前类的实例。

实现方式

1. 懒汉式(线程不安全)

  • 描述:这是最基本的实现方式,实例对象在第一次被调用的时候才会被创建,属于懒加载,延迟创建单例。
  • 优点:懒加载模式下,如果没有使用到该类,那么就不会实例化对象,节约了资源。
  • 缺点:这种实现方式不支持多线程,这是最主要的问题,因为没有加锁 synchronized,无法实现线程安全。在执行if (Instance == null)时,如果多个线程同时进入,并且此时Instance 为 null,那么这些线程就会在执行new语句,导致多次实例化对象,这是我们不希望看到的。
public class Singleton {  
    private static Singleton instance;  //声明静态变量
    private Singleton (){}   //构造器
  
    public static Singleton getInstance() {  
        if (instance == null) {  
            instance = new Singleton();  
        }  
        return instance;  
    }  
}

2. 懒汉式(线程安全)

  • 描述:实例对象在也是第一次被调用的时候才会被创建,属于懒加载,通过静态同步方法解决线程安全问题。
  • 优点:懒加载,节约内存资源。使用同步方法,在某个时间点只能有一个线程能够进入方法,避免了多次实例化的问题,因此支持多线程,保证了线程安全。
  • 缺点:我们希望在创建实例的时间点进行加锁同步,用静态同步方法会使得同步的范围太大,另外每次要创建对象都要争抢锁,未进入方法的线程必须等待性能会有损耗,效率不高
public class Singleton {  
    private static Singleton instance;  
    private Singleton (){}  
    public static synchronized Singleton getInstance() {  //使用同步方法
        if (instance == null) {  
            instance = new Singleton();  
        }  
        return instance;  
    }  
}

3. 饿汉式(线程安全)

  • 描述:线程不安全问题主要是由于Instance可被多次实例化,因此,在类加载时就直接实例化Instance就可以保证线程安全问题。它基于 累加载机制避免了多线程的同步问题,不过这时候初始化instance显然没有达到懒加载(lazy loading)的效果。
  • 优点:未使用同步锁,执行效率会有所提高,线程安全。
  • 缺点:直接在类加载时自动实例化对象,失去了懒加载机制下节约资源的优势,消耗内存。
public class Singleton {  
    private static Singleton instance = new Singleton();  //类加载时就进行实例化
    private Singleton (){}  
    public static Singleton getInstance() {  
    return instance;  
    }  
}

注:懒汉式与饿汉式最主要的区别在于创建单例的时机不同,懒汉式根据是否需要实例,手动创建;饿汉式在类加载时自动创建单例

4. 双重校验锁方式(线程安全)

  • 描述:双重校验锁(double-checked locking,DCL)也叫双检锁,JDK1.5出现的功能。这种方式采用双锁机制,同时加锁操作只需要对实例化那部分代码进行,只有当Instance没有被实例化时(Instance == null) ,才需要进行加锁。

  • 优点:懒加载,多线程环境下可保证线程安全,性能较高。

  • 缺点:相比前几种方式,实现较为复杂。

  • 双重校验锁的完善过程:

  1. 由于使用懒汉式同步方法会消耗过多性能,我们只在构建实例对象的时候进行同步。在调用getInstance()时,访问的线程不需要竞争锁,都可以直接进入。再进行下一步判断,若此时实例对象还没有被构建,线程开始竞争锁,抢到锁的线程开始创建单例。
public class Singleton {
    private static Singleton Instance;
    private Singleton() {}

    public static Singleton getInstance() {
        if (Instance == null) {
            synchronized (Singleton.class) {  //在需要构建单例的时候给Class对象加锁
               Instance = new Singleton();
            }
        }
        return Instance;
    }
}

问题:在多个线程执行判断条件时,虽然只有一个线程能够抢到锁取创建单例,但是可能有其他线程已经进入了if代码块,之后会再进行if判断了,而这些线程等待释放锁后,随即又会创建实例对象,最终实例会被多次被创建。显然线程不安全。

  1. 再增加一条判断条件,这也是双重校验锁中“双重”的由来。我们假设线程A抢到同步锁,然后创建实例,创建完毕释放锁。这时,线程B抢到锁,进行判断实例是否被创建,发现实例instance已经被线程A初始化了,不可能等于null,直接退出,返回A线程创建的单例。
public class Singleton {
    private static Singleton Instance;
    private Singleton() {}

    public static Singleton getInstance() {
        if (Instance == null) {
            synchronized (Singleton.class) {  //在需要构建单例的时候给Class对象加锁
            if (Instance == null) {          //增加了判空条件
              	  Instance = new Singleton();
            	}
            }
        }
        return Instance;
    }
}
  1. 在执行 Instance = new Singleton();时,大致可以分为三步:1)给Instance实例分配内存;2)初始化Instance的构造器;3)将instance对象指向分配的内存地址(这一步Instance就非null了)。由于JVM为了优化指令,提高程序的运行效率,允许指令重排,导致在程序实际运行的时候,顺序变为1)>> 3)>> 2),这在单线程的情况下是没有问题的。但是,在多线程的环境下,线程有可能拿到一个尚未被初始化的实例,程序必然报错使用 volatile 关键字可以禁止 JVM 的指令重排,保证在多线程环境下也能正常运行。
public class Singleton {  
    private volatile static Singleton Instance;  //增加volatile关键字,防止JVM指令重排
    private Singleton (){}  
    
    public static Singleton getInstance() {  
    if (Instance == null) {  
        synchronized (Singleton.class) {  
            if (Instance == null) {  
                Instance = new Singleton();  
            }  
        }  
    }  
    return singleton;  
    }  
}

5.静态内部类方式

  • 描述:这种方式能达与双检锁功能相似,且实现更简单。由于静态内部类的加载是在程序中调用静态内部类的时候加载的,和外部类的加载没有必然关系,因此当 Singleton 类加载时,静态内部类 SingletonHolder 并没有被加载进内存。只有当调用 getInstance() 方法从而触发 SingletonHolder.INSTANCE 时 ,SingletonHolder 才会被加载,此时初始化INSTANCE实例。实现了延迟加载。 这种方式只适用于静态域的情况,双检锁方式可在实例域需要延迟初始化时使用。
  • 优点:延时加载,按需加载,节约资源;由于JVM提供了对线程安全的支持,只会加载一遍,线程安全得到保证。
  • 缺点:这种方式只适用于静态域的情况。
public class Singleton {
    private Singleton() {
    }
	//静态内部类
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {  
        return SingletonHolder.INSTANCE;    //访问静态内部类中静态成员
    }
}

6.枚举方式

  • 描述:这是实现单例模式的最佳方法。这种方式是《Effective Java》作者 Joshua Bloch 提倡的方式,它不仅能避免多线程同步问题,而且还自动支持序列化机制,防止反序列化重新创建新的对象,绝对防止多次实例化。出现反射攻击时,通过 setAccessible() 方法可以将私有构造函数的访问级别设置为 public,然后调用构造函数从而实例化对象。如果要防止这种攻击,需要在构造函数中添加防止实例化第二个对象的代码。解决序列化和反射攻击很麻烦,而枚举实现不会出现这两种问题,因此说枚举实现单例模式式最佳实践方法。
  • 优点:单例模式的最佳实践,它实现简单,并且在面对复杂的序列化或者反射攻击的时候,不能调用private方法,能够防止多次实例化,是目前最安全的实现单例的方法。
  • 缺点:这种方式尚未被广泛采用,实际工作中,很少会被采用。
public enum Singleton {  
    INSTANCE;  
    public void whateverMethod() {  //任意方法
    }  
}

结语

  一般情况下,不建议使用两种懒汉式实现单例模式;明确使用静态方法和实现懒加载效果时,会采用静态内部类方式;涉及到反序列化创建对象的时候,可以使用枚举方式;一般而言,饿汉式以及双重校验锁比较常用。

    原文作者:Joe__Bryant
    原文地址: https://www.cnblogs.com/KobeForever/p/WhereAmazingHappens1.html
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞