单例模式(Singleton)

一、模式动机

对于系统中的某些类来说，有且只能有一个实例。例如：一个系统只能有一个窗口管理器。系统中可以有许多打印机，但是只能有一个打印机正在工作。

• 问题
  我们怎样保证一个类只有一个实例并且这个实例易于被访问呢？

• 解决方法
  让类自身负责保存它的唯一实例。这个类可以保证没有其它实例被创建，并且它可以提供一个访问该实例的方法。这就是单例模式——Singleton Pattern。

二、模式定义

单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。

• 要点
  
  • 某个类只能有一个实例
  • 它必须自行创建这个实例
  • 它必须自行向整个系统提供这个实例

单例模式是一种对象创建型模式。

三、模式结构

四、参与者

Singleton单例

五、模式分析

1. 私有化构造方法

• 要想在运行期间控制某一个类的实例只有一个，首要的任务就是要控制创建实例的地方
• private Singleton(){ }

2. 提供获取实例的方法

• 单例模式决定让这个类提供一个方法来返回类的实例，方便外面使用。
• public Singleton GetInstance(){}

3. 获取实例的静态方法

• 在方法上加上static，这样就可以直接通过类来调用这个方法，而不需要先得到类实例。
• public static Singleton GetInstance(){ }

4. 定义存储实例的属性

• public static Singleton GetInstance() { return new Singleton(); }
• 用一个属性来记录自己创建好的类实例
• private static Singleton instance = null;

5. 实现控制实例的创建

  public static Singleton getInstance()
  {
     //先判断instance是否有值    
     if(instance == null)
     {
        //如果没有值，说明还没有创建过实例，那就创建一个
        //并把这个实例设置给instance
        instance = new Singleton ();
     }
      //如果有值，或者是创建了值，那就直接使用
      return instance;
  } 

6. 完整的实现

public class Singleton 
{
    //4：定义一个变量来存储创建好的类实例
    //5：因为这个变量要在静态方法中使用，所以需要加上static修饰
    private static Singleton instance = null;
    //1：私有化构造方法，便于在内部控制创建实例的数目
    private Singleton()
    {    
    }
    //2：定义一个方法来为客户端提供类实例
    //3：这个方法需要定义成类方法，也就是要加static
    public static Singleton GetInstance(){
        //6：判断存储实例的变量是否有值
        if(instance == null){
            //6.1：如果没有，就创建一个类实例，并把值赋给存储类实例的变量
            instance = new Singleton();
        }
        //6.2：如果有值，那就直接使用
        return instance;
    }
}

• 优点

  • 提供了对唯一实例的受控访问。
  • 由于系统中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象，单例模式无疑可以提高系统的性能。
  • 允许可变数目的实例。可以对单例模式进行扩展，设计指定个数的实例对象，即节省系统资源，又解决了由于单例对象共享过多有损性能的问题。

• 缺点

  • 由于单例模式中没有抽象层，因此单例类的扩展有很大困难。
  • 单例类的职责过重，在一定程度上违背了单一指责原则。因为单例模式即提供业务方法，又提供了创建对象的方法，将对象功能和创建耦合在一起。
  • 很多面向对象语言的GC垃圾回收技术，实例化的对象长期不使用，系统会认为是垃圾，自动销毁并回收资源，这将导致共享的单例对象状态的丢失。

六、模式扩展

1. 高并发、线程不安全

/**
 * 单例模式类
 * @author Administrator
 *
 */
public class Singleton {
    private String name;
    private static Singleton singleton;
    private Singleton(String name) {
        this.name = name;
    }
    public void show() {
        System.out.println(name);
    }
    public static Singleton getInstance(String name) {
        if (singleton == null) {
            singleton = new Singleton(name);        
        }
        return singleton;
    }

    public static void main(String[] args) {
        // 主函数创建两个线程并发访问
        new Thread(new GetSingleton("hehe")).start();
        new Thread(new GetSingleton("haha")).start();
    }

}

/**
 * 使用单例的类
 * @author Administrator
 *
 */
class GetSingleton implements Runnable {
    String str;
    public GetSingleton(String str) {
        this.str = str;
    }
    public void run() {
        Singleton.getInstance(str).show();
    }
}

   如果在首次调用 GetInstance（）时，是由两个线程同时调用的（这种情况是很常见的）。
   一个线程进入 if 判断语句后但还没有实例化 Singleton 时，第二个线程到达，此时 singleton 还是为 null，这样的话，两个线程均会进入 GetInstance（），问题就出来了，因为有两个线程，所以会创建两个实例。

我们做如下改进：

private static Integer lock = 1;        // 锁
public static Singleton getInstance(String name) {
    if (singleton == null) {    // 性能
        synchronized (lock) {   // 单线程
            if (singleton == null) // 单一实例
                singleton = new Singleton(name);
        }
    }
    return singleton;
}

双重检查锁定(Double-Check Locking )

• 如果没有第一重 singleton == null 的话，每一次有线程调用GetInstance（）时，均会执行锁定操作来实现线程同步，这是非常耗费性能的。
• 而如果加上第一重 singleton == null 的话，那么就只有在第一次，也就是 singleton ==null 成立时的情况下执行一次锁定以实现线程同步，而以后的话，便只要直接返回 Singleton 实例就 OK 了而根本无需再进入 lock 语句块了，这样就可以解决由线程同步带来的性能问题了。

2. 懒汉式单例

• 单例模式在整个应用程序的生命周期中只存在一个实例
• 懒汉式单例就是这个单例类的这个唯一实例new是在第一次使用 GetInstance()时实例化的
• 如果不调用 GetInstance()的话，这个实例是不会存在的，即为 null
• 前面在介绍单例模式的这几个 Demo 中都是使用的懒汉式单例

3. 饿汉式单例

• 主动实例化单例类的这个唯一类
• private static readonly Singleton singleton = new Singleton();
• C# 与 CLR 会自动解决前面提到的懒汉式单例类时出现的多线程同步问题

4. 单例模式—管理多个对象

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

/**
 * 单例模式类
 * @author Administrator
 *
 */
public class Singleton {
    private static List<Singleton> singletons;
    private static int size = 5;
    private Singleton() {
    }
    public static Singleton getInstance() {

        if (singletons == null) {
            singletons = new ArrayList<Singleton>();
            for (int i=0; i<size; i++) {
                singletons.add(new Singleton());
            }
        }
        int k = new Random().nextInt(size);
        return singletons.get(k);
    }

    public static void main(String[] args) {
        Singleton s1 = Singleton.getInstance();
        for (int i=0; i<6; i++) {
            Singleton s2 = Singleton.getInstance();
            if (s1 == s2) 
                System.out.println("s1 equals to s2");
            else 
                System.out.println("s1 not equals to s2");
        }
    }

}