设计模式——单例模式

引言

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

　　软件设计领域的四位世界级大师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
```
) ，才需要进行加锁。
优点： 懒加载，多线程环境下可保证线程安全，性能较高。
缺点： 相比前几种方式，实现较为复杂。
双重校验锁的完善过程：

由于使用懒汉式同步方法会消耗过多性能，我们只在构建实例对象的时候进行同步。在调用
```
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() {  //任意方法

    }  

}

结语

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

设计模式——单例模式

引言

类的构成

实现方式

结语

添加新评论

最新文章

分类

最近回复

归档

其它