JDK源码——单例模式

JDK源码中单例模式的应用

1、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运行时对象的引用。

验证：

 Runtime r1 = Runtime.getRuntime();
 Runtime r2 = Runtime.getRuntime();
 System.out.println(r1 == r2);

运行结果：

true

2、java.awt.Toolkit#getDefaultToolkit()

懒汉式单例。不需要事先创建好，只要在第一次真正用到的时候再创建就可以了。因为很多时候并不常用Java的GUI和其中的对象。如果使用饿汉单例的话会影响JVM的启动速度。

 public abstract class 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本身是个抽象类不能实例化对象，而是通过反射机制加载类并创建新的实例。

3、java.awt.GraphicsEnvironment#getLocalGraphicsEnvironment()

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

 private static GraphicsEnvironment createGE() {
         GraphicsEnvironment ge;
         String nm = AccessController.doPrivileged(new GetPropertyAction("java.awt.graphicsenv", null));
         try {
             Class<GraphicsEnvironment> geCls;
             try {
             geCls = (Class<GraphicsEnvironment>)Class.forName(nm);
             } catch (ClassNotFoundException ex) {
                 ClassLoader cl = ClassLoader.getSystemClassLoader();
                 geCls = (Class<GraphicsEnvironment>)Class.forName(nm, true, cl);
             }
             ge = geCls.newInstance();
             if (isHeadless()) {
                 ge = new HeadlessGraphicsEnvironment(ge);
             }
         } catch (ClassNotFoundException e) {
             throw new Error("Could not find class: "+nm);
         } catch (InstantiationException e) {
             throw new Error("Could not instantiate Graphics Environment: "
                             + nm);
         } catch (IllegalAccessException e) {
             throw new Error ("Could not access Graphics Environment: "
                              + nm);
         }
         return ge;
     }
 }

这里类加载时只静态声明了私有localEnv并没有创建实例对象。在GraphicsEnvironment类被第一次调用时会创建该对象。这里的createGE()方法也是通过反射的方式创建对象的。

总结：

(1)当一个类的对象只需要或者只可能有一个时，应该考虑单例模式。

(2)如果一个类的实例应该在JVM初始化时被创建出来，应该考虑使用饿汉式。

(3)如果一个类的实例不需要预先被创建，也许这个类的实例并不一定能用得上，也许这个类的实例创建过程比较耗费时间，也许就是真的没必要提前创建。那么应该考虑懒汉式。

(4)在使用懒汉式单例的时候，应该考虑到线程的安全性问题。

参考博客：http://www.hollischuang.com/archives/1383