Java设计模式_(创建型)_单例模式

 

1  概述

单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中一个类只有一个实例。即一个类只有一个对象实例.

数学与逻辑学中，singleton定义为“有且仅有一个元素的集合”。

单例模式最初的定义出现于《设计模式》（艾迪生维斯理,1994）：“保证一个类仅有一个实例，并提供一个访问它的全局访问点。”

Java中单例模式定义：“一个类有且仅有一个实例，并且自行实例化向整个系统提供。”

 

 

 

2  实现方式

2.1 饿汉式

public class EHSingletion {
    //当类装载的时候就会创建类的实例，先创建出来，然后每次调用的时候，就不需要再判断，节省了运行时间。
    private static EHSingletion obj = new EHSingletion();
 
    // 私有化对象实例化方法
    private EHSingletion() {
    }
    // 公有获取实例方法
    public static EHSingletion getInstance() {
        return obj;
    }
}

说明：

上面的例子中，在这个类被加载时，静态变量obj会被初始化，此时类的私有构造子会被调用。这时候，单例类的唯一实例就被创建出来了。

“饿汉式”其实是一种比较形象的称谓。表示在装载类的时候就创建对象实例，然后每次调用的时候，就不需要再判断，节省了运行时间。但是如果从来没使用过的话，实例实现创建也浪费了空间。

 

 

 

2.2 懒汉式

public class LazySingleton {
    //"懒汉式"则实例对象实现为空，需要时才创建
    private static LazySingleton instance = null;
 
    // 私有默认构造子
    private LazySingleton() {
    }
 
    //获取对象方法
    public static synchronized LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

说明：

上面的懒汉式单例类实现里对静态工厂方法使用了同步化，以处理多线程环境。“懒汉式” 其实是一种比较形象的称谓。既：在装载对象的时候不创建对象实例。在需要的时候才判断是否已有对象，如果没有则创建，和之前的“饿汉式”刚好相区分。唯一缺陷就是每次获取实例都会进行判断，看是否需要创建实例，浪费判断的时间。

 

 

 

2.3 线程同步双重加锁

在Java中经常会遇到多线程的问题，因此线程同步非常必要，

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

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

“双重检查加锁”机制的实现会使用关键字volatile，它的意思是：被volatile修饰的变量的值，将不会被本地线程缓存(根据jvm的存储机制，每个方法都存入各自的方法栈)，所有对该变量的读写都是直接操作共享内存，从而确保多个线程能正确的处理该变量。

如下代码：

public class ThreadSecurity {
    //初始化实例为空，并用volatile修饰
    private volatile static ThreadSecurity instance = null;
    //私有化类构造器
    private ThreadSecurity(){}
    //公有获取实例方法
    public static ThreadSecurity getInstance(){
        if (instance==null) {
            synchronized(ThreadSecurity.class){
                //再次判断实例是否需要创建
                if (instance==null) {
                   instance = new ThreadSecurity();
                }
            }
        }
        return instance;
    }
}

　　这种实现方式既可以实现线程安全地创建实例，而又不会对性能造成太大的影响。它只是第一次创建实例的时候同步，以后就不需要同步了，从而加快了运行速度。

　　注意：由于volatile关键字可能会屏蔽掉虚拟机中一些必要的代码优化，所以运行效率并不是很高。所以一般情况下没有特别的需要，不要使用。也就是说，虽然可以使用“双重检查加锁”机制来实现线程安全的单例，但并不建议大量采用，可以根据情况来选用。

 

 

2.4 类级内部类方式实现

根据上面的几种代码实现分析，以上常见的几种单例实现方式都存在小小的缺陷，要么就是线程不安全，要么就是实例事先加载了耗费了资源。那么有没有一种方案，既能实现延迟加载，又能实现线程安全呢？

答案肯定是可以的，可以使用类级内部类来实现，类级内部类即：有static修饰的成员式内部类

在多线程开发中，为了解决并发问题，主要是通过使用synchronized来加互斥锁进行同步控制。但是在某些情况中，JVM已经隐含地为您执行了同步，这些情况下就不用自己再来进行同步控制了。这些情况包括：

　　1.由静态初始化器（在静态字段上或static{}块中的初始化器）初始化数据时

　　2.访问final字段时

　　3.在创建线程之前创建对象时

4.线程可以看见它将要处理的对象时

因此解决方案就是：

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

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

示例代码如下：

public class InneSingleton{
    // 私有默认构造子
    private InneSingleton() {
    }
 
    // 类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例没有绑定关系，而且只有被调用到时才会装载，从而实现了延迟加载。
    private static class SingletonHolder {
        // 静态初始化器，由JVM来保证线程安全
        private static InneSingletoninstance = new InneSingleton();
    }
 
    // 公有获取实例方法
    public static InneSingletongetInstance() {
        return SingletonHolder.instance;
    }
}

说明：

　　当getInstance方法第一次被调用的时候，它第一次读取SingletonHolder.instance，导致SingletonHolder类得到初始化；而这个类在装载并被初始化的时候，会初始化它的静态域，从而创建Singleton的实例，由于是静态的域，因此只会在虚拟机装载类的时候初始化一次，并由虚拟机来保证它的线程安全性。

　　这个模式的优势在于，getInstance方法并没有被同步，并且只是执行一个域的访问，因此延迟初始化并没有增加任何访问成本。