JAVA设计模式 — 单例模式(Singleton)

定义：确保一个类仅有一个实例，并且提供一个访问它的全局访问点。

类型：对象创建型模式

单例模式的结构

Singleton：
负责创建Singleton类自己的唯一实例，并提供一个getInstance的方法，让外部来访问这个类的唯一实例。

单例模式应该是23种设计模式中最简单的一种模式了。它有以下几个要素：

• 私有的构造方法
• 私有静态的类自身实例引用
• 以自己实例为返回值的静态的公有的方法

        单例模式根据实例化对象时机的不同分为两种：一种是饿汉式单例，一种是懒汉式单例。饿汉式单例在单例类被加载时候，就实例化一个对象交给自己的引用；而懒汉式在调用取得实例方法的时候才会实例化对象。

懒汉式实现示例代码如下：

package com.example.test;/** * 懒汉式单例实现的示例 */public class Singleton {/** * 定义一个变量来存储创建好的类实例 */private static Singleton instance = null;   /** * 私有化构造方法，可以在内部控制创建实例的数目 */    private Singleton(){        }        /**     * 定义一个方法来为客户端提供类实例     * @return     */    public static synchronized Singleton getInstance(){        //判断存储类实例的变量是否有值        if(instance==null){         //如果没有，就创建一个类实例，并把值赋值给存储类实例的变量            instance = new Singleton();            }            return instance;        }          /**     * 示意方法，单例可以有自己的操作     */    public void operation(){    //功能处理    }}

饿汉式实现示例代码如下：

package com.example.test.ch1;/** * 饿汉式单例实现的示例 */public class Singleton {/** * 定义一个变量来存储创建好的类实例,直接在这里创建类实例，只能创建一次 */private static Singleton instance = new Singleton();   /** * 私有化构造方法，可以在内部控制创建实例的数目 */    private Singleton(){        }        /**     * 定义一个方法来为客户端提供类实例     * @return     */    public static Singleton getInstance(){        //直接使用已经创建好的类实例        return instance;        }          /**     * 示意方法，单例可以有自己的操作     */    public void operation(){    //功能处理    }}

单例模式的优缺点

1、时间和空间

比较以上两种写法：懒汉式是典型的时间换空间，也就是每次获取实例都会进行判断，看是否需要创建实例，浪费判断的时间。当然，如果一直没有人使用的话，那就不会创建实例，节省内存空间。

饿汉式是典型的空间换时间，当类被加载的时候就会创建类实例，不管你用不用都先创建出来，然后每次调用的时候，就不需要再判断了，节省了运行时间。

2、线程安全

(1)、从线程安全上讲，不加同步的懒汉式是线程不安全的，而饿汉式是线程安全的，因为虚拟机保证只会装载一次，在装载类的时候是不会发生并发的。

(2)、如何实现懒汉式的线程安全

当然懒汉式也是可以实现线程安全的，只需要加上synchronized即可，如下：

public static synchronized Singleton getInstance(){        //判断存储类实例的变量是否有值        if(instance==null){         //如果没有，就创建一个类实例，并把值赋值给存储类实例的变量            instance = new Singleton();            }            return instance;        }

但这样一来，会降低整个访问速度，而且每次都要判断。那么有没有更好的方式来实现呢？

(3)、双重检查加锁

可以使用双重检查加锁 的方式来实现，就可以既实现线程安全，又能够使线程不受到很大的影响。

所谓双重检查加锁机制，指的是：并不是每次进入getInstance方法都需要同步，而是先不同步，进入方法过后，先检查实例是否存在，如果不存在才进入下面的同步块，这是第一重检查。进入同步块过后，再次检查实例是否存在，如果不存在，就在同步的情况下创建一个实例，这是第二重检查。这样一来，就只需要同步一次了，从而减少了多次在同步情况下进行判断所浪费的时间。

双重检查加锁机制的实现会使用一个关键字volatile，它的意思是：被volatile修饰的变量的值，将不会被本地线程缓存，所有对该变量的读写都是直接操作共享内存，从而确保多个线程能正确的处理该变量。

示例代码如下：

package com.example.test;/** * 双重检查 单例实现的示例 */public class Singleton {/** * 定义一个变量来存储创建好的类实例 */private volatile static Singleton instance = null;   /** * 私有化构造方法，可以在内部控制创建实例的数目 */    private Singleton(){        }        /**     * 定义一个方法来为客户端提供类实例     * @return     */    public static Singleton getInstance(){        //先检查实例是否存在，如果不存在才进入下面的同步块        if(instance==null){         synchronized (Singleton.class) {        //同步块，线程安全地创建实例if(instance==null){//再次检查实例是否存在，如果不存在才真正地创建实例            instance = new Singleton();    }}        }            return instance;        }          /**     * 示意方法，单例可以有自己的操作     */    public void operation(){    //功能处理    }}

一种更好的单例实现方式

根据上面的分析，常见的两种单例实现方式都存在小小的缺陷，那么有没有一种方案，既能够实现延迟加载，又能够实现线程安全呢？

要想简单的实现线程安全，可以采用静态初始化器的方式，它可以由JVM来保证线程的安全性。比如前面的饿汉式实现方式。但是这样一来，不是会浪费一定的空间吗？因为这种实现方式，会在类装载的时候就初始化对象，不过你需不需要。

如果现在有一种方法能够让类装载的时候不去初始化对象，那不就解决问题了？一种可行的方式就是采用类级内部类，在这个类级内部类里面去创建对象实例。这样一来，只要不使用到这个类级内部类，那就不好创建对象实例，从而同时实现延迟加载和线程安全。

这个解决方案被称为Lazy Initialization holder class模式，这个模式综合使用了Java类级内部类和多线程缺省同步锁的知识，很巧妙地同时实现了延迟加载和线程安全。

示例代码如下：

package com.example.test;/** * Lazy Initialization holder class模式 示例 */public class Singleton {/** * 类级内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例没有绑定关系， * 而且只有被调用时才会装载，从而实现了延迟加载 */private static class SingletonHolder{/** * 静态初始化器，由JVM来保证线程安全 */private static Singleton instance = new Singleton();  }/** * 私有化构造方法，可以在内部控制创建实例的数目 */    private Singleton(){        }        /**     * 定义一个方法来为客户端提供类实例     * @return     */    public static Singleton getInstance(){        return SingletonHolder.instance;    }  }

单例模式的本质

单例模式的本质：控制实例的数目。

何时选用单例模式

建议在如下情况时，选用单例模式。

当需要控制一个类的实例只能有一个，而且客户只能从一个全局访问点访问它时，可以选用单例模式，这些功能恰好是单例模式所要解决的问题。