Java 单例模式

Question

作为对象的创建模式，单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类。

单例模式的特点

1. 单例类只能有一个实例。
2. 单例类必须自己创建自己的唯一实例。
3. 单例类必须给所有其他对象提供这一实例。

单例模式的写法有好几种，这里主要介绍三种：懒汉式单例、饿汉式单例、登记式单例

懒汉式单例类

• 懒汉式单例类.在第一次调用的时候实例化自己
• 懒汉式是典型的时间换空间,就是每次获取实例都会进行判断，看是否需要创建实例，浪费判断的时间。当然，如果一直没有人使用的话，那就不会创建实例，则节约内存空间

public class Singleton {
    private  Singleton(){

    }
    //懒汉式单例类.在第一次调用的时候实例化自己
    private static Singleton single=null;

    //静态工厂方法 在第一次调用的时候实例化自己
    public static  Singleton getInstance(){
        if(single==null){
            single = new Singleton();
        }
        return single;
    }
}

饿汉式单例

• 饿汉式在类初始化时就已经创建好一个静态的对象供系统使用，以后不再改变，所以天生是线程安全的。
• 饿汉式是典型的空间换时间，当类装载的时候就会创建类的实例，不管你用不用，先创建出来，然后每次调用的时候，就不需要再判断，节省了运行时间。

class Singleton2{
    private Singleton2() {}
    private  static  Singleton2 instance=new Singleton2();

    public static Singleton2 getInstance2(){
        return instance;
    }
}

双重检查加锁实现单例模式

• 线程环境下懒汉式单例模式是线程不安全可能会出现多个实例，可以使用“双重检查加锁”的方式来实现，就可以既实现线程安全，又能够使性能不受很大的影响
• 所谓“双重检查加锁”机制，指的是：并不是每次进入 getInstance 方法都需要同步，而是先不同步，进入方法后，先检查实例是否存在，如果不存在才进行下面的同步块，这是第一重检查，进入同步块过后，再次检查实例是否存在，如果不存在，就在同步的情况下创建一个实例，这是第二重检查。这样一来，就只需要同步一次了，从而减少了多次在同步情况下进行判断所浪费的时间。
• 双重检查加锁”机制的实现会使用关键字 volatile，它的意思是：被 volatile 修饰的变量的值，将不会被本地线程缓存，所有对该变量的读写都是直接操作共享内存，从而确保多个线程能正确的处理该变量

//双重锁检查单例模式
class  Singleton3{
    private  Singleton3(){}
    private static Singleton3 single=null;
    //静态工厂方法 在第一次调用的时候实例化自己
    public static  Singleton3 getInstance3(){
        //先检查实例是否存在，如果不存在才进入下面的同步块
        if(single==null){
           synchronized (Singleton3.class){
               //再次判断实例是否存在，不存在 则创建
               if(single==null){
                   single=new Singleton3();
               }
           }
        }
        return single;
    }
}

Lazy initialization holder class 模式

• 这个模式综合使用了 Java 的类级内部类和多线程缺省同步锁的知识，很巧妙地同时实现了延迟加载和线程安全。

什么是类级内部类？

1. 类级内部类指的是，有 static 修饰的成员式内部类。如果没有 static 修饰的成员式内部类被称为对象级内部类。
2. 类级内部类相当于其外部类的 static 成分，它的对象与外部类对象间不存在依赖关系，因此可直接创建。而对象级内部类的实例，是绑定在外部对象实例中的。
3. 类级内部类中，可以定义静态的方法。在静态方法中只能够引用外部类中的静态成员方法或者成员变量。
4. 类级内部类相当于其外部类的成员，只有在第一次被使用的时候才被会装载。

多线程缺省同步锁的知识

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

这些情况包括：

1. 由静态初始化器（在静态字段上或 static{}块中的初始化器）初始化数据时
2. 访问 final 字段时
3. 创建线程之前创建对象时
4. 线程可以看见它将要处理的对象时

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

public class Singleton4 {
    private Singleton4(){}
    /**
     *    类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例
     *    没有绑定关系，而且只有被调用到时才会装载，从而实现了延迟加载。
     */
    private static class SingletonHolder{
        /**
         * 静态初始化器，由 JVM 来保证线程安全
         */
        private static Singleton4 instance = new Singleton4();
    }

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


}

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

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

单例和枚举

使用枚举来实现单实例控制会更加简洁，而且无偿地提供了序列化机制，并由 JVM 从根本上提供保障，绝对防止多次实例化，是更简洁、高效、安全的实现单例的方式。

public class DataSource {

}

public enum SingletonEnum {

    /**
     * 定义一个枚举元素,代表了 Singleton 的一个实例
     */
    uniqueInstance;

    private  DataSource data=null;

    private SingletonEnum() {
        data = new DataSource();
    }
    public DataSource getConnection() {
        return data;
    }
}


public class SingletonEnumTest {

    public static void main(String[] args) {
        DataSource d=new DataSource();
        DataSource d2=new DataSource();
        System.out.println("使用枚举单列前------------------");
        System.out.println(d==d2);

        DataSource d3=SingletonEnum.uniqueInstance.getConnection();
        DataSource d4=SingletonEnum.uniqueInstance.getConnection();

        ExecutorService exec=Executors.newCachedThreadPool();
        for (int i = 0; i <10 ; i++) {
            exec.execute(new Runnable() {
                @Override
                public void run() {
                    DataSource d3=SingletonEnum.uniqueInstance.getConnection();
                    DataSource d4=SingletonEnum.uniqueInstance.getConnection();
                    System.out.println("枚举单列模式使用-----");
                    System.out.println(d3==d4);
                }
            });

        }

    }
}