设计模式-单例模式

单例模式

《大话设计模式》–http://download.youkuaiyun.com/detail/ws_flying/9881735

目录

• 单例模式
• 模式动机
• 模式定义
• 模式结构
• 时序图
• 代码分析
• 模式分析
• 实例
• 优点
• 缺点
• 适用环境
• 模式应用
• 模式扩展

1. 模式动机
对于系统中的某些类来说，只有一个实例很重要，例如，一个系统中可以存在多个打印任务，但是只能有一个正在工作的任务；一个系统只能有一个窗口管理器或文件系统；一个系统只能有一个计时工具或ID（序号）生成器。

如何保证一个类只有一个实例并且这个实例易于被访问呢？定义一个全局变量可以确保对象随时都可以被访问，但不能防止我们实例化多个对象。

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

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

单例模式的要点有三个：一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。单例模式是一种对象创建型模式。单例模式又名单件模式或单态模式。

3. 模式结构
单例模式包含如下角色：

Singleton：单例

4. 时序图

5. 代码分析

/**
 * 懒汉式，线程不安全
 * 
 * @author 80011670
 * @date 2017年6月9日
 *
 */
public class Singleton {
    //不初始化，延迟加载，用到的时候才初始化
    private static Singleton instance;

    //私有化构造函数，防止通过new获取对象
    private Singleton() {
    }

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }   
}

/**
 * 饿汉式，线程不安全
 * 
 * @author 80011670
 * @date 2017年6月9日
 *
 */
public class Singleton1 {

    private static final Singleton1 instance = new Singleton1();

    private Singleton1() {
    }

    public static Singleton1 getInstance() {
        return instance;
    }
}

/**
 * 懒汉式，线程安全
 * 
 * @author 80011670
 * @date 2017年6月9日
 *
 */
public class Singleton2 {
    private static Singleton2 instance;

    private Singleton2() {
    }

    public static synchronized Singleton2 getInstance() {
        if (instance == null) {
            instance = new Singleton2();
        }

        return instance;
    }
}

/**
 * 双重校验，线程安全 jdk1.5以后适用（jdk1,5开始才开始引入禁止指令重排序这条语义）
 * 
 * @author 80011670
 * @date 2017年6月9日
 *
 */
public class Singleton3 {
    /**
     * 定义一个静态私有变量(不初始化，不使用final关键字，使用volatile保证了多线程访问时instance变量的可见性，避免了instance初始化时其他变量属性还没赋值完时，被另外线程调用)
     * 
     * volatile作用 1、可见性，在一个线程中对该变量的修改会马上由工作内存（Work Memory）写回主内存（Main
     * Memory），所以会马上反应在其它线程的读取操作中
     * 2、禁止指令重排序，编译器会自动优化我们写的代码，实际的执行顺序可能与我们所写的顺序不同，编译器只保证程序的运行结果跟源代码一致。
     * 单线程下没问题，但是多线程下会出现问题，使用volatile可以避免该问题
     */
private static volatile Singleton3 instance;

    private Singleton3() {
    }

    public static Singleton3 getInstance() {
        if (instance == null) {
            synchronized (Singleton3.class) {
                if (instance == null) {
                    instance = new Singleton3();
                }
            }
        }

        return instance;
    }
}

/**
 * 静态内部类方式
 * 
 * @author 80011670
 * @date 2017年6月9日
 *
 */
public class Singleton4 {
    private Singleton4() {
    }

    private static class SingletonHolder {
        private static Singleton4 instance = new Singleton4();
    }

    public static Singleton4 getInstance() {
        return SingletonHolder.instance;
    }
}

6. 模式分析
单例模式的目的是保证一个类仅有一个实例，并提供一个访问它的全局访问点。单例模式包含的角色只有一个，就是单例类——Singleton。单例类拥有一个私有构造函数，确保用户无法通过new关键字直接实例化它。除此之外，该模式中包含一个静态私有成员变量与静态公有的工厂方法，该工厂方法负责检验实例的存在性并实例化自己，然后存储在静态成员变量中，以确保只有一个实例被创建。

在单例模式的实现过程中，需要注意如下三点：

• 单例类的构造函数为私有；
• 提供一个自身的静态私有成员变量；
• 提供一个公有的静态工厂方法。

7. 实例
在操作系统中，打印池(Print Spooler)是一个用于管理打印任务的应用程序，通过打印池用户可以删除、中止或者改变打印任务的优先级，在一个系统中只允许运行一个打印池对象，如果重复创建打印池则抛出异常。现使用单例模式来模拟实现打印池的设计。

8. 优点

• 提供了对唯一实例的受控访问。因为单例类封装了它的唯一实例，所以它可以严格控制客户怎样以及何时访问它，并为设计及开发团队提供了共享的概念。
• 由于在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象，单例模式无疑可以提高系统的性能。
• 允许可变数目的实例。我们可以基于单例模式进行扩展，使用与单例控制相似的方法来获得指定个数的对象实例。

9. 缺点
由于单例模式中没有抽象层，因此单例类的扩展有很大的困难。

• 单例类的职责过重，在一定程度上违背了“单一职责原则”。因为单例类既充当了工厂角色，提供了工厂方法，同时又充当了产品角色，包含一些业务方法，将产品的创建和产品的本身的功能融合到一起。
• 滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；现在很多面向对象语言(如Java、C#)的运行环境都提供了自动垃圾回收的技术，因此，如果实例化的对象长时间不被利用，系统会认为它是垃圾，会自动销毁并回收资源，下次利用时又将重新实例化，这将导致对象状态的丢失。

10. 适用环境
在以下情况下可以使用单例模式：

• 系统只需要一个实例对象，如系统要求提供一个唯一的序列号生成器，或者需要考虑资源消耗太大而只允许创建一个对象。
• 客户调用类的单个实例只允许使用一个公共访问点，除了该公共访问点，不能通过其他途径访问该实例。
  在一个系统中要求一个类只有一个实例时才应当使用单例模式。反过来，如果一个类可以有几个实例共存，就需要对单例模式进行改进，使之成为多例模式

11. 模式应用
一个具有自动编号主键的表可以有多个用户同时使用，但数据库中只能有一个地方分配下一个主键编号，否则会出现主键重复，因此该主键编号生成器必须具备唯一性，可以通过单例模式来实现。

12. 模式扩展

• 通过反射或反序列化话获取对象

public class Test {

    @SuppressWarnings("unchecked")
    public static void main(String[] args) throws Exception {
        Singleton instance = Singleton.getInstance();

        //通过反射获取对象
        Class<Singleton> clazz = (Class<Singleton>) Class.forName("com.xx.pattern.singletonpattern.Singleton");
        Constructor<Singleton> c = clazz.getDeclaredConstructor();
        c.setAccessible(true);
        Singleton s1 = c.newInstance();
        Singleton s2 = c.newInstance();
        System.out.println(s1 == s2);

        //通过反序列化获取对象
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("F:/demo/cc.txt"));
        out.writeObject(instance);
        out.close();

        ObjectInputStream in = new ObjectInputStream(new FileInputStream("F:/demo/cc.txt"));
        Singleton s3 = (Singleton) in.readObject();
        System.out.println(instance == s3);
        in.close();

    }
}

• 防止利用反射破坏单例模式
• • 常用方式

    //私有化构造函数，防止通过new获取对象
    private Singleton() {
        /**
         * 通过抛出异常，阻止通过反射获取多个对象
         * 该方式只有在instance实例化后才能起作用，比如调用getInstance()方法后
         */
        if (instance != null) {
            throw new RuntimeException();
        }
    }

• • 静态内部类方式

private Singleton4() {
        //通过抛出异常，阻止通过反射获取多个对象
        if (SingletonHolder.instance != null) {
            throw new RuntimeException();
        }
    }

• 防止反序列化破坏单例模式

/**
 * 通过重写readResolve()防止反序列化获取多个对象
 * @return instance
 */
private Object readResolve() throws ObjectStreamException {    
    return instance;  
}  

13. 总结

• 单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。单例模式的要点有三个：一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。单例模式是一种对象创建型模式。
• 单例模式只包含一个单例角色：在单例类的内部实现只生成一个实例，同时它提供一个静态的工厂方法，让客户可以使用它的唯一实例；为了防止在外部对其实例化，将其构造函数设计为私有。
• 单例模式的目的是保证一个类仅有一个实例，并提供一个访问它的全局访问点。单例类拥有一个私有构造函数，确保用户无法通过new关键字直接实例化它。除此之外，该模式中包含一个静态私有成员变量与静态公有的工厂方法。该工厂方法负责检验实例的存在性并实例化自己，然后存储在静态成员变量中，以确保只有一个实例被创建。
• 单例模式的主要优点在于提供了对唯一实例的受控访问并可以节约系统资源；其主要缺点在于因为缺少抽象层而难以扩展，且单例类职责过重。
• 单例模式适用情况包括：系统只需要一个实例对象；客户调用类的单个实例只允许使用一个公共访问点。