java设计模式之单例模式-伊成个人站

单例模式的介绍

单例模式的定义就是确保某一个类只有一个实例，并且提供一个全局访问点。
主要有三个特点：

只有一个实例。
自我实例化。
提供全局访问点。

当系统中只需要一个实例对象或者系统中只允许一个公共访问点，除了这个公共访问点外，不能通过其他访问点访问该实例时，就可以使用单例模式。

单例模式UML类图

“伊成博客”

单例模式的八种方式

饿汉式（静态常量）
饿汉式（静态代码块）
懒汉式（线程不安全）
懒汉式（线程安全，同步方法）
懒汉式（线程安全，同步代码块）
双重检查
静态内部类
枚举

1、饿汉式（静态常量）【可用】

public class Singleton {
    private final static Singleton INSTANCE = new Singleton();
    private Singleton(){}
    public static Singleton getInstance(){
        return INSTANCE;
    }
}

优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。
缺点：在类装载的时候就完成实例化，没有达到Lazy Loading的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费。

这种方式基于classloder机制避免了多线程的同步问题，不过，instance在类装载时就实例化，在单例模式中大多数都是调用getlnstance方法，但是导致类装载的原因有很多种，因此不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance就没有达到 lazy loading的效果。

结论：这种单例模式可用，可能造成内存浪费。

2、饿汉式（静态代码块）【可用】

public class Singleton {
    private static Singleton instance;
    static {
        instance = new Singleton();
    }
    private Singleton() {}
    public static Singleton getInstance() {
        return instance;
    }
}

这种方式和上面的方式其实类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。优缺点和上面是一样的。

结论：这种单例模式可用，但可能造成内存浪费。

3、懒汉式（线程不安全）【不可用】

public class Singleton {
    private static Singleton singleton;
    private Singleton() {}
    public static Singleton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

优点：起到了Lazy Loading的效果，但是只能在单线程下使用。
缺点：在多线程下，一个线程进入if (singleton == null)判断语句块，还没来得及往下执行，另一个线程也通过这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式。

结论：在实际开发中，不要使用这种方式。

4、懒汉式（线程安全，同步方法）【不推荐使用】

public class Singleton {
    private static Singleton singleton;
    private Singleton() {}
    public static synchronized Singleton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

优点：解决了线程不安全问题。
缺点：效率太低了，每个线程想获得类的实例的时候，执行getInstance()方法都要进行同步。其实这个方法只执行一次实例化代码就可以了，后面的想获得类的实例，直接return就行了，方法进行同步效率太低。

结论：在实际开发中，不推荐使用这种方式。

5、懒汉式（线程安全，同步代码块）【不可用】

public class Singleton {
    private static Singleton singleton;
    private Singleton() {}
    public static Singleton getInstance() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                singleton = new Singleton();
            }
        }
        return singleton;
    }
}

优点：这种方式本意是想对第四种方式的改进，以为前面同步方法效率太低，改为同步产生实例化的代码块。
缺点：这种同步不能起到线程同步的作用。和第三种方式遇到的情形一致，如果一个线程进入了if (singleton == null) 判断语句块，还未来的及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。

结论：在实际开发中，不能使用这种方式。

6、双重检查【推荐使用】

public class Singleton {
    private static volatile Singleton singleton;
    private Singleton() {}
    public static Singleton getInstance() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

优点：Double Check概念是多线程开发中常使用到的，如代码中所示，我们进行两次 if (singleton == null)检查，这样可以保证线程安全。实例化代码只用执行一次，后面再次访问时，判断if (singleton == null)的时候，直接return实例化对象，也避免了反复进行方法同步。
线程安全，延迟加载，效率较高。

结论：在实际开发中，推荐使用这种方式。

7、静态内部类【推荐使用】

public class Singleton {
    private Singleton() {}
    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }
    public static Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
静态内部类方式在singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载singletonInstance类，从而完成Singleton的实例化。
类的静态属性只会在第一次加载类的时候初始化，所以在这里，ⅣM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。

优点：避免了线程不安全，利用静态内部类特点实现了延迟加载，效率高。

结论：在实际开发中，推荐使用。

8、枚举 [推荐使用]

public enum Singleton {
    INSTANCE;
    public void whateverMethod() {
    }
}

优点：借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。

结论：推荐使用。

单例模式使用案例

1、Runtime类中使用了饿汉式单例模式。如下代码：

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

    /**
     * Returns the runtime object associated with the current Java application.
     * Most of the methods of class <code>Runtime</code> are instance
     * methods and must be invoked with respect to the current runtime object.
     *
     * @return  the <code>Runtime</code> object associated with the current
     *          Java application.
     */
    public static Runtime getRuntime() {
        return currentRuntime;
    }
    
    /** Don't let anyone else instantiate this class */
    private Runtime() {}

}

2、Spring源码中 AbstractBeanFactory 的 getBean 里， getBean 的 doGetBean 方法调用 getSingleton 进行bean的创建。

/**

 * Return the (raw) singleton object registered under the given name.
  
   * <p>Checks already instantiated singletons and also allows for an early
  
   * reference to a currently created singleton (resolving a circular reference).
  
   * @param beanName the name of the bean to look for
  
   * @param allowEarlyReference whether early references should be created or not
  
   * @return the registered singleton object, or {@code null} if none found
     */
     @Nullable
     protected Object getSingleton(String beanName, boolean allowEarlyReference) {
     Object singletonObject = this.singletonObjects.get(beanName);
     if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
      synchronized (this.singletonObjects) {
         singletonObject = this.earlySingletonObjects.get(beanName);
         if (singletonObject == null && allowEarlyReference) {
            ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
            if (singletonFactory != null) {
               singletonObject = singletonFactory.getObject();
               this.earlySingletonObjects.put(beanName, singletonObject);
               this.singletonFactories.remove(beanName);
            }
         }
      }
   }
   return singletonObject;
   }

从上面代码可以看到，spring依赖注入时，使用了双重判断加锁的单例模式。

3、Spring aop中的GlobalAdvisorAdapterRegistry类

“伊成博客”

/**

 * Singleton to publish a shared DefaultAdvisorAdapterRegistry instance.
   *

 * @author Rod Johnson

 * @author Juergen Hoeller

 * @author Phillip Webb

 * @see DefaultAdvisorAdapterRegistry
   */
   public final class GlobalAdvisorAdapterRegistry {

   private GlobalAdvisorAdapterRegistry() {
   }


   /**
    * Keep track of a single instance so we can return it to classes that request it.
    */
   private static AdvisorAdapterRegistry instance = new DefaultAdvisorAdapterRegistry();

   /**
    * Return the singleton {@link DefaultAdvisorAdapterRegistry} instance.
    */
   public static AdvisorAdapterRegistry getInstance() {
      return instance;
   }

}

The end.