文章概要

1、什么是單例
2、為什么需要單例
3、單例的優(yōu)點和缺點
4、單例的寫法和比較
5、序列化破壞單例
6、反射破壞單例
7、不使用synchronized和lock，如何實現(xiàn)一個線程安全的單例？
8、JDK中的單例
9、引用

1、什么是單例

單例是23中設計模式之一，保證一個類只有一個實例，并且對外提供統(tǒng)一的訪問入口。是創(chuàng)建型模式。

2、為什么需要單例

我們都知道，類的對象是由類的構造函數(shù)創(chuàng)建的，若構造函數(shù)是public的，則外部可以通過構造函數(shù)隨意創(chuàng)建對象，若想限制類對象的創(chuàng)建，可以將構造函數(shù)改為private，至少也要protected。但是要保證類的可用性，就需要對外提供一個方法用于訪問該類。

3、單例的優(yōu)點和缺點

優(yōu)點：在內存中一個類只有一個實例，避免對象的不斷創(chuàng)建和銷毀，減少內存開銷
缺點：在編寫單例代碼時需要解決線程安全問題和序列化問題

4、單例的寫法和比較

單例的寫法分為餓漢式、懶漢式、靜態(tài)內部類、枚舉、

①餓漢式

public class Singleton {
    //實例化
    private static Singleton instance = new Singleton();
    
    //私有化的構造函數(shù)
    private Singleton(){}
    
    //對外提供一個統(tǒng)一獲取實例的靜態(tài)方法
    public static Singleton getInstance(){
        return instance;
    }
}

線程安全：安全。因為instance對象是static修飾的，在類第一次被加載時，instance就已經被初始化完成，所以線程安全。
缺點：類第一次被加載時就實例化，若實例用不到，會造成資源的浪費。若類被多次加載，會產生多個實例化對象。

②靜態(tài)內部類

public class Singleton {

    //私有化的構造函數(shù)
    private Singleton(){}

    //靜態(tài)內部類實例化
    private static class SingletonHolder{
        private static final Singleton INSTANCE = new Singleton();
    }

    //對外提供統(tǒng)一方法
    public static Singleton getInstance(){
        return SingletonHolder.INSTANCE;
    }
}

靜態(tài)內部類的方式解決了餓漢式資源浪費的問題，當Singleton類第一次被加載時，instance不一定初始化，只有顯示調用getInstance()方法時，才會裝載SingletonHolder類，進而instance被初始化，這種延遲加載的方式解決了餓漢式浪費資源的問題。
線程安全：安全。與餓漢式一樣用static修飾，利用classLoader機制的線程安全性保證此種單例的線程安全。

③懶漢式

public class Singleton {

    private static Singleton instance;

    //私有化的構造函數(shù)
    private Singleton(){}

    //對外提供統(tǒng)一方法
    public static Singleton getInstance(){
        if (null == instance){
            instance = new Singleton();
        }
        return instance;
    }
}

懶漢式是在對象第一次被使用時初始化instance。
線程安全：不安全。若線程A和線程B同時請求調用getInstance()方法，當A進入if判斷，但是沒有執(zhí)行new操作時，B也進行if判斷，此時inatance為null，這種情況線程A和線程B會分別new不同的Singleton對象。

④懶漢式改進版一

public class Singleton {

    private static Singleton instance;

    //私有化的構造函數(shù)
    private Singleton(){}

    //對外提供統(tǒng)一方法
    public static synchronized Singleton getInstance(){
        if (null == instance){
            instance = new Singleton();
        }
        return instance;
    }
}

為了解決懶漢式的線程安全問題，用synchronized修飾方法。
線程安全：安全。
缺點：由于getInstance方法被整個鎖住，所以多線程環(huán)境下，此方法是串行執(zhí)行的，執(zhí)行效率低。

⑤懶漢式改進版二

public class DoubleCheckLazySingleton {
    private  static  DoubleCheckLazySingleton instance;

    private DoubleCheckLazySingleton(){};

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

雙重校驗鎖懶漢式單例，將synchronized鎖范圍縮小至初始化代碼，從而提高執(zhí)行效率，采用兩次空值判斷。
線程安全：不安全。
缺點：JVM可以執(zhí)行重排序，指令的執(zhí)行順序：（1）分配內存給instance對象。（2）初始化instance對象。（3）設置instance對象指向分配內存地址。正常我們認為的執(zhí)行順序是（1）（2）（3），由于指令重排序機制，最后執(zhí)行的順序可能是（1）（3）（2），此時線程A執(zhí)行（3），但沒有執(zhí)行（2），線程B進來之后判斷instance對象非空（正在執(zhí)行（2）或者未執(zhí)行（2）），程序會產生錯誤。
那么如何解決上面的問題呢？volatile解決線程間的可見性和指令重排序問題。

public class DoubleCheckLazySingleton {
    private volatile static  DoubleCheckLazySingleton instance;

    private DoubleCheckLazySingleton(){};

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

將instance變量用volatile修飾之后可解決以上問題。
但是它只是看上去完美無缺，其實還是有問題的。
缺點：序列化問題（后續(xù)展開說明）

⑥枚舉單例

public enum EnumSingleton {
    INSTANCE;

    private EnumSingleton(){};

    public static EnumSingleton getInstance(){
        return INSTANCE;
    }
}

這種方式是Effective Java作者Josh Bloch 提倡的方式。枚舉類型單例，即解決了線程安全問題，有解決了序列化問題。
優(yōu)點：

線程安全

枚舉在底層做了線程安全的操作。

public final class EnumSingleton extends Enum
{

    public static EnumSingleton[] values()
    {
        return (EnumSingleton[])$VALUES.clone();
    }

    public static EnumSingleton valueOf(String name)
    {
        return (EnumSingleton)Enum.valueOf(com/xxx/EnumSingleton, name);
    }

    private EnumSingleton(String s, int i)
    {
        super(s, i);
    }

    public static EnumSingleton getInstance()
    {
        return INSTANCE;
    }

    public static final EnumSingleton INSTANCE;
    private static final EnumSingleton $VALUES[];

    static 
    {
        INSTANCE = new EnumSingleton("INSTANCE", 0);
        $VALUES = (new EnumSingleton[] {
            INSTANCE
        });
    }
}

以上代碼是枚舉類反編譯之后的代碼，我們發(fā)現(xiàn)變成了繼承Enum類的final class類，變量instance用static修飾，instance的初始化在static塊中，其實就是上面我們講到的餓漢式單例。所以是線程安全的。

5、序列化破壞單例：

其他的單例模式都會有序列化問題，我們來以雙重校驗鎖單例對象的序列化和反序列化做個測試：

public class SerializableTest {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("testFile"));
        //寫入雙重校驗鎖單例對象
        DoubleCheckLazySingleton s1 = DoubleCheckLazySingleton.getInstance();
        oos.writeObject(s1);
        oos.flush();
        oos.close();

        //反序列化
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("testFile"));
        DoubleCheckLazySingleton s2 = (DoubleCheckLazySingleton) ois.readObject();
        ois.close();

        System.out.println("s1:"+s1);
        System.out.println("s2:"+s2);
        System.out.println("s1==s2:"+ (s1==s2));

    }
}

輸出結果：

s1:com.zhangjq.DoubleCheckLazySingleton@14ae5a5
s2:com.zhangjq.DoubleCheckLazySingleton@6d03e736
s1==s2:false

從結果可以看出序列化和反序列化不是同一個對象，那么是什么原因造成的呢？我們來看源碼分析：
ObjectInputStream.readObject()

    public final Object readObject()
        throws IOException, ClassNotFoundException
    {
        if (enableOverride) {
            return readObjectOverride();
        }

        // if nested read, passHandle contains handle of enclosing object
        int outerHandle = passHandle;
        try {
            Object obj = readObject0(false);
            handles.markDependency(outerHandle, passHandle);
            ClassNotFoundException ex = handles.lookupException(passHandle);
            if (ex != null) {
                throw ex;
            }
            if (depth == 0) {
                vlist.doCallbacks();
            }
            return obj;
        } finally {
            passHandle = outerHandle;
            if (closed && depth == 0) {
                clear();
            }
        }
    }

在這里調用了readObject0(),在這個方法中可以看到

private Object readObject0(boolean unshared) throws IOException {
      ...
      case TC_OBJECT:
      return checkResolve(readOrdinaryObject(unshared));
      ...
}

我們繼續(xù)進入readOrdinaryObject方法

private Object readOrdinaryObject(boolean unshared)
        throws IOException
    {
        if (bin.readByte() != TC_OBJECT) {
            throw new InternalError();
        }

        ObjectStreamClass desc = readClassDesc(false);
        desc.checkDeserialize();

        Class<?> cl = desc.forClass();
        if (cl == String.class || cl == Class.class
                || cl == ObjectStreamClass.class) {
            throw new InvalidClassException("invalid class descriptor");
        }

        Object obj;
        try {
            obj = desc.isInstantiable() ? desc.newInstance() : null;
        } catch (Exception ex) {
            throw (IOException) new InvalidClassException(
                desc.forClass().getName(),
                "unable to create instance").initCause(ex);
        }
        ·········
        return obj;
    }

可以看到這樣一段代碼obj = desc.isInstantiable() ? desc.newInstance() : null;
進入isInstantiable方法，發(fā)現(xiàn)就是一個判斷是否存在無參構造函數(shù)的語句

/** serialization-appropriate constructor, or null if none */
    private Constructor<?> cons;
·········
/**
     * Returns true if represented class is serializable/externalizable and can
     * be instantiated by the serialization runtime--i.e., if it is
     * externalizable and defines a public no-arg constructor, or if it is
     * non-externalizable and its first non-serializable superclass defines an
     * accessible no-arg constructor.  Otherwise, returns false.
     */
boolean isInstantiable() {
        requireInitialized();
        return (cons != null);
    }

綜合以上所述：我們發(fā)現(xiàn)只要序列化的類存在無參構造函數(shù)就調用desc.newInstance()，構造一個新的對象返回。

解決方案：

只需要在序列化的類中添加readResolve()方法即可解決序列化問題

public class DoubleCheckLazySingleton implements Serializable{
    private volatile static  DoubleCheckLazySingleton instance;

    private DoubleCheckLazySingleton(){};

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

    private Object readResolve(){
        return instance;
    }
}

再次運行序列化和反序列化操作，結果如下：

s1:com.zhangjq.DoubleCheckLazySingleton@14ae5a5
s2:com.zhangjq.DoubleCheckLazySingleton@14ae5a5
s1==s2:true

為什么添加readResolve()方法就可以解決序列化問題呢？我們來看源碼：
在readOrdinaryObject()方法中，判斷是否存在無參構造函數(shù)之后，又判斷了是否存在readResolve()的方法

if (obj != null &&
            handles.lookupException(passHandle) == null &&
            desc.hasReadResolveMethod())
        {
            Object rep = desc.invokeReadResolve(obj);
            if (unshared && rep.getClass().isArray()) {
                rep = cloneArray(rep);
            }
            if (rep != obj) {
                // Filter the replacement object
                if (rep != null) {
                    if (rep.getClass().isArray()) {
                        filterCheck(rep.getClass(), Array.getLength(rep));
                    } else {
                        filterCheck(rep.getClass(), -1);
                    }
                }
                handles.setObject(passHandle, obj = rep);
            }
        }

hasReadResolveMethod:

/**
     * Returns true if represented class is serializable or externalizable and
     * defines a conformant readResolve method.  Otherwise, returns false.
     */
    boolean hasReadResolveMethod() {
        requireInitialized();
        return (readResolveMethod != null);
    }

若存在則執(zhí)行hasReadResolveMethod方法，結果覆蓋上面new 出來的對象，返回。
那么readResolveMethod 是在哪里賦值的呢？通過全局查找找到了賦值代碼在私有方法
ObjectStreamClass()方法中給 readResolveMethod 進行賦值，來看代碼：

readResolveMethod = getInheritableMethod(cl, "readResolve", null, Object.class);

在 invokeReadResolve()方法中用反射調用了 readResolveMethod 方法。
通過 JDK 源碼分析我們可以看出，雖然，增加 readResolve()方法返回實例，解決了單
例被破壞的問題。但是，我們通過分析源碼以及調試，我們可以看到實際上實例化了兩
次，只不過新創(chuàng)建的對象沒有被返回而已。那如果，創(chuàng)建對象的動作發(fā)生頻率增大，就
意味著內存分配開銷也就隨之增大。

枚舉單例序列化

對上述測試代碼做修改

public class SerializableTest {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("testFile"));
        //寫入雙重校驗鎖單例對象
//        DoubleCheckLazySingleton s1 = DoubleCheckLazySingleton.getInstance();
        EnumSingleton s1 = EnumSingleton.getInstance();
        oos.writeObject(s1);
        oos.flush();
        oos.close();

        //反序列化
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("testFile"));
//        DoubleCheckLazySingleton s2 = (DoubleCheckLazySingleton) ois.readObject();
        EnumSingleton s2 = (EnumSingleton) ois.readObject();
        ois.close();

        System.out.println("s1:"+s1);
        System.out.println("s2:"+s2);
        System.out.println("s1==s2:"+ (s1==s2));

    }
}

運行結果：

s1:INSTANCE
s2:INSTANCE
s1==s2:true

沒什么任何附加的操作，就可以保證序列化問題，我們來看源碼分析：
繼續(xù)分析ObjectInputStream.readObject()，在readObject0方法中

                case TC_ENUM:
                    return checkResolve(readEnum(unshared));

我們看到在 readObject0()中調用了 readEnum()方法，來看 readEnum()中代碼實現(xiàn)：

    private Enum<?> readEnum(boolean unshared) throws IOException {
        if (bin.readByte() != TC_ENUM) {
            throw new InternalError();
        }

        ObjectStreamClass desc = readClassDesc(false);
        if (!desc.isEnum()) {
            throw new InvalidClassException("non-enum class: " + desc);
        }

        int enumHandle = handles.assign(unshared ? unsharedMarker : null);
        ClassNotFoundException resolveEx = desc.getResolveException();
        if (resolveEx != null) {
            handles.markException(enumHandle, resolveEx);
        }

        String name = readString(false);
        Enum<?> result = null;
        Class<?> cl = desc.forClass();
        if (cl != null) {
            try {
                @SuppressWarnings("unchecked")
                Enum<?> en = Enum.valueOf((Class)cl, name);
                result = en;
            } catch (IllegalArgumentException ex) {
                throw (IOException) new InvalidObjectException(
                    "enum constant " + name + " does not exist in " +
                    cl).initCause(ex);
            }
            if (!unshared) {
                handles.setObject(enumHandle, result);
            }
        }

        handles.finish(enumHandle);
        passHandle = enumHandle;
        return result;
    }

可以看出枚舉對象反序列化時是通過Enum.valueOf()方法根據(jù)名字查找枚舉對象 。不存在new新對象的情況，所以枚舉單例的反序列化問題是安全的。

6、反射破壞單例

在上述所有的單例模式中，構造方法都是private權限的，很多人以為只要設置成private就是安全的了，其實不然，利用反射機制可以強制訪問private的構造方法來創(chuàng)建對象。我們來看一個例子：

public class ReflectSingletonTest {
    public static void main(String[] args) throws IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException {
        //以雙重校驗鎖單例為例
        Class<?> clazz = DoubleCheckLazySingleton.class;
        Constructor<?> declaredConstructor = clazz.getDeclaredConstructor();

        //設置強制訪問
        declaredConstructor.setAccessible(true);

        //初始化
        Object o1 = declaredConstructor.newInstance();
        Object o2 = declaredConstructor.newInstance();

        System.out.println("o1:"+o1);
        System.out.println("o2:"+o2);
        System.out.println("o1==o2:"+ (o1==o2));
    }
}

運行結果：

  o1:com.zhangjq.DoubleCheckLazySingleton@1b6d3586
o2:com.zhangjq.DoubleCheckLazySingleton@4554617c
o1==o2:false

解決方案:

針對這種情況，我們可以在構造函數(shù)里面加一些判斷，來解決反射破壞單例的問題：

public class DoubleCheckLazySingleton implements Serializable{
    private volatile static  DoubleCheckLazySingleton instance;
    private volatile static boolean initialized = false;
    private DoubleCheckLazySingleton(){
        if(!initialized){
            initialized = !initialized;
        }else{
           throw new RuntimeException("不允許重復創(chuàng)建DoubleCheckLazySingleton對象！");
        }  
    }

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

    private Object readResolve(){
        return instance;
    }
}

再次運行結果如下：

java.lang.reflect.InvocationTargetException
    at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
    at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
    at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
    at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
    at com.zhangjq.ReflectSingletonTest.main(ReflectSingletonTest.java:25)
Caused by: java.lang.RuntimeException: 不允許創(chuàng)建多個實例
    at com.zhangjq.LazyDoubleCheckSingleton.<init>(LazyDoubleCheckSingleton.java:13)
    ... 5 more

枚舉單例反射問題

那么枚舉類型的單例是否存在反射問題呢？

public class ReflectSingletonTest {
    public static void main(String[] args) throws IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException {
        //以雙重校驗鎖單例為例
        Class<?> clazz = EnumSingleton.class;
        Constructor<?> declaredConstructor = clazz.getDeclaredConstructor(null);

        //設置強制訪問
        declaredConstructor.setAccessible(true);

        //初始化
        Object o1 = declaredConstructor.newInstance();
        Object o2 = declaredConstructor.newInstance();

        System.out.println("o1:"+o1);
        System.out.println("o2:"+o2);
        System.out.println("o1==o2:"+ (o1==o2));
  }
}

輸出結果：

Exception in thread "main" java.lang.NoSuchMethodException: com.zhangjq.EnumSingleton.<init>()
    at java.lang.Class.getConstructor0(Class.java:3082)
    at java.lang.Class.getDeclaredConstructor(Class.java:2178)
    at com.zhangjq.ReflectSingletonTest.main(ReflectSingletonTest.java:13)

異常的意思是沒有找到EnumSingleton無參的構造函數(shù)。
查看Enum類的源碼發(fā)現(xiàn)只有一個帶參數(shù)的構造函數(shù)

protected Enum(String name, int ordinal) {
        this.name = name;
        this.ordinal = ordinal;
    }

我們將代碼修改一下，再次運行：

public class ReflectSingletonTest {
    public static void main(String[] args) throws IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException {
        //以雙重校驗鎖單例為例
        Class<?> clazz = EnumSingleton.class;
        Constructor<?> declaredConstructor = clazz.getDeclaredConstructor(String.class,int.class);

        //設置強制訪問
        declaredConstructor.setAccessible(true);

        //初始化
        Object o1 = declaredConstructor.newInstance("zhang",10);
        Object o2 = declaredConstructor.newInstance("wang",11);

        System.out.println("o1:"+o1);
        System.out.println("o2:"+o2);
        System.out.println("o1==o2:"+ (o1==o2));

Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects
    at java.lang.reflect.Constructor.newInstance(Constructor.java:417)
    at com.zhangjq.ReflectSingletonTest.main(ReflectSingletonTest.java:19)

報錯信息很明顯：不能用反射創(chuàng)建枚舉類對象。
我們查看newInstance()方法的源碼

    public T newInstance(Object ... initargs)
        throws InstantiationException, IllegalAccessException,
               IllegalArgumentException, InvocationTargetException
    {
        if (!override) {
            if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                Class<?> caller = Reflection.getCallerClass();
                checkAccess(caller, clazz, null, modifiers);
            }
        }
        if ((clazz.getModifiers() & Modifier.ENUM) != 0)
            throw new IllegalArgumentException("Cannot reflectively create enum objects");
        ConstructorAccessor ca = constructorAccessor;   // read volatile
        if (ca == null) {
            ca = acquireConstructorAccessor();
        }
        @SuppressWarnings("unchecked")
        T inst = (T) ca.newInstance(initargs);
        return inst;
    }

可以看出當修飾符是枚舉類型時，拋出異常，也就是說jdk控制反射不能創(chuàng)建枚舉類對象。所以枚舉類的反射破壞問題是不存在的。

7、不使用synchronized和lock，如何實現(xiàn)一個線程安全的單例？

以上我們講的所有單例的線程安全都顯示或者隱示的用到了ClassLoader的線程安全機制。
餓漢式：用static修飾，類第一次被加載時實例化，ClassLoader的類加載是synchronized修飾的。
懶漢式：顯示的用synchronized修改。
枚舉：編譯器編譯之后枚舉中的所有變量都用static final 修飾，并且是初始化在static塊中
那么如果我們不用synchronized和lock，如何實現(xiàn)一個線程安全的單例呢？
答案是：CAS

CAS是項樂觀鎖技術，當多個線程嘗試使用CAS同時更新同一個變量時，只有其中一個線程能更新變量的值，而其它線程都失敗，失敗的線程并不會被掛起，而是被告知這次競爭中失敗，并可以再次嘗試。
實現(xiàn)單例代碼：

public class Singleton {
    private static final AtomicReference<Singleton> INSTANCE = new AtomicReference<Singleton>(); 

    private Singleton() {}

    public static Singleton getInstance() {
        for (;;) {
            Singleton singleton = INSTANCE.get();
            if (null != singleton) {
                return singleton;
            }

            singleton = new Singleton();
            if (INSTANCE.compareAndSet(null, singleton)) {
                return singleton;
            }
        }
    }
}

優(yōu)點：CAS依賴底層硬件的實現(xiàn)，沒有線程之間切換和阻塞問題。
缺點：可能一直處于等待中，不斷的循環(huán)，對CPU造成資源開銷。

8、JDK中的單例

java.lang.Runtime

Runtime類封裝了Java運行時的環(huán)境。每一個java程序實際上都是啟動了一個JVM進程，那么每個JVM進程都是對應這一個Runtime實例，此實例是由JVM為其實例化的。每個 Java 應用程序都有一個 Runtime 類實例，使應用程序能夠與其運行的環(huán)境相連接。
由于Java是單進程的，所以，在一個JVM中，Runtime的實例應該只有一個。所以應該使用單例來實現(xiàn)。

public class Runtime {
    private static Runtime currentRuntime = new Runtime();

    public static Runtime getRuntime() {
        return currentRuntime;
    }

    private Runtime() {}
}

以上代碼為JDK中Runtime類的部分實現(xiàn)，可以看到，這其實是餓漢式單例模式。在該類第一次被classloader加載的時候，這個實例就被創(chuàng)建出來了。

一般不能實例化一個Runtime對象，應用程序也不能創(chuàng)建自己的 Runtime 類實例，但可以通過 getRuntime 方法獲取當前Runtime運行時對象的引用。

9、引用

參考：
單例與序列化的那些事兒
設計模式（二）——單例模式
不使用synchronized和lock，如何實現(xiàn)一個線程安全的單例？
JDK中的那些單例