設計模式（三）——JDK中的那些單例

櫻桃大丸子 8年前發布 | 11K 次閱讀設計模式

在設計模式（二）——單例模式中介紹了單例的概念、用途、實現方式、如何防止被序列化破壞等。單例模式在JDK源碼中也有多處應用。本文通過JDK（java 8）中幾個典型的單例的使用來復習一下單例模式，并且通過這種實際應用來深入理解一下單例的用法與實現方式。

java.lang.Runtime

Runtime類封裝了Java運行時的環境。每一個java程序實際上都是啟動了一個JVM進程，那么每個JVM進程都是對應這一個Runtime實例，此實例是由JVM為其實例化的。每個 Java 應用程序都有一個 Runtime 類實例，使應用程序能夠與其運行的環境相連接。

由于Java是單進程的，所以，在一個JVM中，Runtime的實例應該只有一個。所以應該使用單例來實現。

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

    public static Runtime getRuntime() {
        return currentRuntime;
    }

    private Runtime() {}
}

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

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

GUI中的單例

除了Runtime是典型的單例以外。JDK中還有幾個類是單例的，他們都是GUI中的類。這幾個單例的類和Runtime最大的區別就在于他們并不是餓漢模式，也就是他們都是惰性初始化的懶漢單例。如果分析其原因的話也比較簡單：那就是他們并不需要事先創建好，只要在第一次真正用到的時候再創建就可以了。因為很多時候我們并不是用Java的GUI和其中的對象。如果使用餓漢單例的話會影響JVM的啟動速度。

由于Java的強項并不是做GUI，所以這幾個類其實并不會經常被用到。筆者也沒用過。把代碼貼到這里，從單例的實現的角度簡單分析一下。

java.awt.Toolkit#getDefaultToolkit()

public abstract class Toolkit {
    /**
     * The default toolkit.
     */
    private static Toolkit toolkit;

     public static synchronized Toolkit getDefaultToolkit() {
            if (toolkit == null) {
                java.security.AccessController.doPrivileged(
                        new java.security.PrivilegedAction<Void>() {
                    public Void run() {
                        Class<?> cls = null;
                        String nm = System.getProperty("awt.toolkit");
                        try {
                            cls = Class.forName(nm);
                        } catch (ClassNotFoundException e) {
                            ClassLoader cl = ClassLoader.getSystemClassLoader();
                            if (cl != null) {
                                try {
                                    cls = cl.loadClass(nm);
                                } catch (final ClassNotFoundException ignored) {
                                    throw new AWTError("Toolkit not found: " + nm);
                                }
                            }
                        }
                        try {
                            if (cls != null) {
                                toolkit = (Toolkit)cls.newInstance();
                                if (GraphicsEnvironment.isHeadless()) {
                                    toolkit = new HeadlessToolkit(toolkit);
                                }
                            }
                        } catch (final InstantiationException ignored) {
                            throw new AWTError("Could not instantiate Toolkit: " + nm);
                        } catch (final IllegalAccessException ignored) {
                            throw new AWTError("Could not access Toolkit: " + nm);
                        }
                        return null;
                    }
                });
                loadAssistiveTechnologies();
            }
            return toolkit;
        }
    }

上面的代碼是Toolkit類的單例實現。這里類加載時只靜態聲明了私有toolkit并沒有創建Toolkit實例對象，延遲加載加快了JVM啟動速度。

單例模式作為一種創建模式，這里在依賴加載的時候應用了另一種創建對象的方式，不是new新的對象，因為Toolkit本身是個抽象類不能實例化對象，而是通過反射機制加載類并創建新的實例。

java.awt.GraphicsEnvironment#getLocalGraphicsEnvironment()

public abstract class GraphicsEnvironment {
    private static GraphicsEnvironment localEnv;
    public static synchronized GraphicsEnvironment getLocalGraphicsEnvironment() {
        if (localEnv == null) {
            localEnv = createGE();
        }

        return localEnv;
    }
}

這里類加載時只靜態聲明了私有localEnv并沒有創建實例對象。在GraphicsEnvironment類被第一次調用時會創建該對象。這里沒有貼出的createGE()方法也是通過反射的方式創建對象的。

java.awt.Desktop#getDesktop()

public class Desktop {

    public static synchronized Desktop getDesktop(){
        if (GraphicsEnvironment.isHeadless()) throw new HeadlessException();
        if (!Desktop.isDesktopSupported()) {
            throw new UnsupportedOperationException("Desktop API is not " +
                                                    "supported on the current platform");
        }

        sun.awt.AppContext context = sun.awt.AppContext.getAppContext();
        Desktop desktop = (Desktop)context.get(Desktop.class);

        if (desktop == null) {
            desktop = new Desktop();
            context.put(Desktop.class, desktop);
        }

        return desktop;
    }
}

上面的代碼看上去和單例不太一樣。但是實際上也是線程安全的懶漢式單例。獲取對象的時候先去環境容器中查找是否存在，不存在實例則創建一個實例。

以上三個類的獲取實例的方法都通過同步方法的方式保證了線程安全。

Runtime類是通過靜態初始化的方式保證其線程安全的。

總結

文中介紹了四個單例的例子，其中有一個是餓漢式單例，三個是懶漢式單例。通過JDK中的實際應用我們可以得出以下結論：

當一個類的對象只需要或者只可能有一個時，應該考慮單例模式。

如果一個類的實例應該在JVM初始化時被創建出來，應該考慮使用餓漢式單例。

如果一個類的實例不需要預先被創建，也許這個類的實例并不一定能用得上，也許這個類的實例創建過程比較耗費時間，也許就是真的沒必須提前創建。那么應該考慮懶漢式單例。

在使用懶漢式單例的時候，應該考慮到線程的安全性問題。