设计模式——单例模式（单例设计模式的作用）

　　本篇文章为你整理了设计模式——单例模式（单例设计模式的作用）的详细内容，包含有设计模式中单例模式的优缺点单例设计模式的作用单例设计模式有哪些特点单例设计模式的应用场景设计模式——单例模式，希望能帮助你了解设计模式——单例模式。

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

　　软件设计领域的四位世界级大师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(){}，公有，静态方法。要向整个系统提供该单例，就要创建一个公有的静态方法向外界提供当前类的实例。

　　
描述：这是最基本的实现方式，实例对象在第一次被调用的时候才会被创建，属于懒加载，延迟创建单例。

　　优点：懒加载模式下，如果没有使用到该类，那么就不会实例化对象，节约了资源。

　　缺点：这种实现方式不支持多线程，这是最主要的问题，因为没有加锁 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) ，才需要进行加锁。

　　
由于使用懒汉式同步方法会消耗过多性能，我们只在构建实例对象的时候进行同步。在调用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判断了，而这些线程等待释放锁后，随即又会创建实例对象，最终实例会被多次被创建。显然线程不安全。

　　再增加一条判断条件，这也是双重校验锁中“双重”的由来。我们假设线程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;

　　在执行 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() { //任意方法

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

　　以上就是设计模式——单例模式（单例设计模式的作用）的详细内容，想要了解更多设计模式——单例模式的内容，请持续关注盛行IT软件开发工作室。

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。

相关文章阅读