Java Singleton(单例模式) 实现详解

什么是单例模式？

Intend:Ensure a class only has one instance, and provide a global point of access to it.

目标：保证一个类只有一个实例，并提供全局访问点

--------（《设计模式：可复用面向对象软件的基础》

就运行机制来说，就是一个类，在运行过程中只存在一份内存空间，外部的对象想使用它，都只会调用那部分内存。

其目的有实现唯一控制访问，节约资源，共享单例实例数据。

单例基础实现有两种思路，

1.Eager initialization：在加载类时构造；2.Lazy Initialization：在类使用时构造；3

1.Eager initialization适用于高频率调用，其由于预先创建好Singleton实例会在初始化时使用跟多时间，但在获得实例时无额外开销

其典型代码如下：

public class EagerInitSingleton {
    //构建实例
    private static final EagerInitSingleton SINGLE_INSTANCE = new EagerInitSingleton();
    //私有化构造器
    private EagerInitSingleton(){}
    //获得实例
    public static EagerInitSingleton getInstance(){
        return SINGLE_INSTANCE;
    }
}

换一种思路，由于类内静态块也只在类加载时运行一次，所以也可用它来代替构造单例：

public class EagerInitSingleton {
    //构建实例
    //private static final EagerInitSingleton instance = new EagerInitSingleton();
    //此处不构造
    private static StaticBlockSingleton instance;

    //使用静态块构造
    static{
        try{
            instance = new StaticBlockSingleton();
        }catch(Exception e){
            throw new RuntimeException("Exception occured in creating singleton instance");
        }
    }

    //私有化构造器
    private EagerInitSingleton(){}
    //获得实例
    public static EagerInitSingleton getInstance(){
        return instance;
    }
}

2.Lazy Initialization适用于低频率调用，由于只有使用时才构建Singleton实例，在调用时会有系列判断过程所以会有额外开销

2.1Lazy Initialization单线程版

其初步实现如下：

public class LazyInitSingleton {

    private static LazyInitSingleton SINGLE_INSTANCE = null;

    //私有化构造器
    private LazyInitSingleton() {}

    //构造实例
    public static LazyInitSingleton getInstance() {
        if (SINGLE_INSTANCE == null) {
          SINGLE_INSTANCE = new LazyInitSingleton();//判断未构造后再构造
        }
        return SINGLE_INSTANCE;
    }
}

2.2Lazy Initialization多线程版

在多线程下，可能多个线程在较短时间内一同调用 getInstance()方法，且判断

SINGLE_INSTANCE == null

结果都为true，则2.1Lazy Initialization单线程版 会构造多个实例，即单例模式失效

作为修正

2.2.1synchronized关键字第一版

可考虑使用synchronized关键字同步获取方法

public class  LazyInitSingleton {

    private static  LazyInitSingleton SINGLE_INSTANCE = null;

    //私有化构造器
    private  LazyInitSingleton() {}

    //构造实例，加入synchronized关键字
    public static synchronized LazyInitSingleton getInstance() {
        if (SINGLE_INSTANCE == null) {
          SINGLE_INSTANCE = new  LazyInitSingleton();//判断未构造后再构造
        }
        return SINGLE_INSTANCE;
    }
}

2.2.2synchronized关键字第二版（double checked locking 二次判断锁）

以上可实现线程安全，但由于使用了synchronized关键字实现锁定控制，getInstance()方法性能下降，造成瓶颈。分析到需求构建操作只限于未构建判断后第一次调用getInstance()方法，即构建为低频操作，所以完全可以在判断已经构建后直接返回，而不需要使用锁，仅在判断需要构建后才进行锁定：

public class  LazyInitSingleton {

    private static  LazyInitSingleton SINGLE_INSTANCE = null;

    //私有化构造器
    private  LazyInitSingleton() {}

    //构造实例
    public static synchronized   LazyInitSingleton getInstance() {
        if (SINGLE_INSTANCE == null) {
            synchronized(LazyInitSingleton.class){
                if (SINGLE_INSTANCE == null) {
                    SINGLE_INSTANCE = new  LazyInitSingleton();//判断未构造后再构造
                }
            }
        }
        return SINGLE_INSTANCE;
    }
}

3利用静态内部类实现懒加载

JVM仅在使用时加载静态资源，当类加载时，静态内部类不会加载，仅当静态内部类在使用时会被加载，且实现顺序初始化即加载是线程安全的，利用这一性质，我们可以实现懒加载

 public class NestedSingleton {

    private NestedSingleton() {}
    //静态内部类，只初始化一次
    private static class SingletonClassHolder {
        static final NestedSingleton SINGLE_INSTANCE = new NestedSingleton();
    }
    //调用静态内部类方法得到单例
    public static NestedSingleton getInstance() {
        return SingletonClassHolder.SINGLE_INSTANCE;
    }

}

4.使用Enum

由于枚举类是线程安全的，可以直接使用枚举创建单例。但考虑到枚举无法继承，所以只在特定情况下使用

public enum EnumSingleton {

    INSTANCE;
}

附1 利用反射机制破解单例（非Enum形式的单例，）

单例形式的类可被反射破解，从而使用单例失效，即将其Private构造器，通过反射形式暴露出来，并进行实例的构造

    public static void main(String[] args) {

        NestedSingleton nestedSingleton =  NestedSingleton.getInstance();
        NestedSingleton nestedSingleton2 = null;
        try {
            //暴露构造器
            Constructor[] constructors = nestedSingleton.getClass().getDeclaredConstructors();
            Constructor constructor = constructors[1];
            constructor.setAccessible(true);
            nestedSingleton2 = (NestedSingleton)constructor.newInstance();

        } catch (Exception e ) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println(nestedSingleton.hashCode());
        System.out.println(nestedSingleton2.hashCode());
    }
}

为防止以上情况，可在构造器中抛出异常，以阻止新的实例产生

public class NestedSingleton {

    private NestedSingleton() {
        synchronized (NestedSingleton.class) {
            //判断是否已有实例
        if(SingletonClassHolder.SINGLE_INSTANCE  != null){
            throw new RuntimeException("new another instance!");
        }
    }

}
//静态内部类，只初始化一次
    private static class SingletonClassHolder {
        static final NestedSingleton SINGLE_INSTANCE = new NestedSingleton();

    }
//调用静态内部类方法得到单例
    public static NestedSingleton getInstance() {
        return SingletonClassHolder.SINGLE_INSTANCE;
    }
}

附2 序列化(Serialization)导致的单例失效

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.io.OutputStream;

public class SingletonSerializedTest   {

    public static void main(String[] args) throws Exception {

        NestedSingleton nestedSingleton0 = NestedSingleton.getInstance();
        ObjectOutput output =null;
        OutputStream outputStream = new FileOutputStream("serializedFile.ser");
        output = new ObjectOutputStream(outputStream);
        output.writeObject(nestedSingleton0);
        output.close();

        ObjectInput input = new ObjectInputStream(new FileInputStream("serializedFile.ser"));
        NestedSingleton nestedSingleton1 = (NestedSingleton) input.readObject();
        input.close();

        System.out.println("nestedSingleton0 hashCode="+nestedSingleton0.hashCode());
        System.out.println("nestedSingleton1 hashCode="+nestedSingleton1.hashCode());

    }
}

输出结果

nestedSingleton0 hashCode=865113938
nestedSingleton1 hashCode=2003749087

显然，产生了两个实例

如果要避免这个情况，则需要利用ObjectInputStream.readObject()中的机制，它在调用readOrdinaryObject()后会判断类中是否有ReadResolve()方法，如果有就采用类中的ReadResolve()新建实例

那么以上单例类就可以如下改造

import java.io.Serializable;

public class NestedSingleton implements Serializable {

    /**
     *
     */
    private static final long serialVersionUID = 3934012982375502226L;
    private NestedSingleton() {
        synchronized (NestedSingleton.class) {
            //判断是否已有实例
        if(SingletonClassHolder.SINGLE_INSTANCE  != null){
            throw new RuntimeException("new another instance!");
        }
    }
}
//静态内部类，只初始化一次
    private static class SingletonClassHolder {
        static final NestedSingleton SINGLE_INSTANCE = new NestedSingleton();
    }
//调用静态内部类方法得到单例
    public static NestedSingleton getInstance() {
        return SingletonClassHolder.SINGLE_INSTANCE;
    }
    public void printFn() {
        // TODO Auto-generated method stub
        System.out.print("fine");
    }
     protected Object readResolve() {
        return getInstance();
    }
}

再次使用序列化反序列化过程验证，得到

nestedSingleton0 hashCode=865113938
nestedSingleton1 hashCode=865113938

这样在序列化反序列化过程保证了单例的实现