Table of Contents generated with DocToc (opens new window)

• 单例(Singleton)模式
  • 优点
  • 应用场景
  • 代码示例

---

单例(Singleton)模式

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法;如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构造器的访问权限设置为private，这样，就不能用new操作符在类的外部产生类的对象了，但在类内部仍可以产生该类的对象。因为在类的外部开始还无法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象，静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象的变量也必须定义成静态的。

优点

由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决。

举例：java.lang.Runtime(饿汉式)

应用场景

• 网站的计数器，一般也是单例模式实现，否则难以同步
• 应用程序的日志应用，一般都使用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。
• 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。
• 项目中，读取配置文件的类，一般也只有一个对象。没有必要每次使用配置文件数据，都生成一个对象去读取。
• Application也是单例的典型应用
• Windows的Task Manager(任务管理器)就是很典型的单例模式
• Windows的Recycle Bin(回收站)也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。

代码示例

1. 非线程安全的(仅懒汉式是线程不安全的，饿汉式天生即线程安全)：

   • 饿汉式

     /**
      * 饿汉式单例模式
      */
     class Bank {
         /**
          * 1.私有化类的构造器
          */
         private Bank() {
     
         }
     
         /**
          * 2.内部创建类的对象,要求此示例对象也是静态的
          */
         private static final Bank instance = new Bank();
     
         /**
          * 3.提供static的方法,返回类的对象
          */
         public static Bank getInstance() {
             return instance;
         }
     }
     

   • 懒汉式

     /**
      * 饿汉式单例模式
      */
     class Order {
         /**
          * 1.私有化类的构造器
          */
         private Order() {
     
         }
     
         /**
          * 2.先声明当前类对象(static),但不初始化
          */
         private static Order instance = null;
     
         /**
          * 3.提供static的方法,返回类的对象
          * 当要获取时,才根据类中的对象是否为null,决定是否初始化instance
          */
         public static Order getInstance() {
             if (instance == null) {
                 instance = new Order();
             }
             return instance;
         }
     }
     

   • 区分饿汉式和懒汉式

     饿汉式：

     ​ 坏处：对象加载时间过长。

     ​ 好处：饿汉式天然就是线程安全的。

     懒汉式：

     ​ 好处：延迟对象的创建。

     ​ 坏处：目前的写法是线程不安全的。

2. 线程安全的懒汉式

   class Student {
       private Student() {
       }
   
       private static Student instance = null;
   
       /**
        * 直接使用同步方法
        * @return
        */
       public synchronized static Student getInstance() {
           synchronized(Student.class){
               if (instance == null) {
                   instance = new Student();
               }
               return instance;
           }
       }
   
       /**
        * 使用同步代码块
        * @return
        */
       public static Student getInstance1() {
           //方式一:效率稍差
   //        synchronized(Student.class){
   //            if (instance == null) {
   //                instance = new Student();
   //            }
   //            return instance;
   //        }
   
           //方式二:效率更高(建议使用)
           if (instance == null) {
               synchronized(Student.class){
                   if (instance == null) {
                       instance = new Student();
                   }
               }
           }
           return instance;
       }
   }
   

3. 双重检测锁定模式的懒汉式单例(Double Check Lock)且防止指令重排

   static class LazySingle {
   
           private static volatile LazySingle INSTANCE = null;
   
           private LazySingle() {
   
           }
           //双重检测锁定模式的懒汉式单例 DCL懒汉式
           public static LazySingle getInstance() {
               if (INSTANCE == null){
                   synchronized (LazySingle.class){
                       if (INSTANCE == null) {
                           INSTANCE = new LazySingle();
                       }
                   }
               }
               return INSTANCE;
           }
       }
   

   • 为什么加了同步锁后还需要二次判空?

     1. 因为如果不二次判空那么有可能会出现以下情况：

     Thread 1	Thread 2
     第一次判定instance为空	第一次判定instance为空
     获取锁	等待1释放锁
     初始化instance	-
     	获取到锁，初始化instance

     这样的话instance就会被初始化两次，所以在获取到锁后还需要进行二次判空。

   • 为什么要使用volatile关键字?

     因为jvm在执行对象初始化的时候可能会进行指令重排

   指令重排： 一般而言初始化操作并不是一个原子操作，而是分为三步：

   1. 在堆中开辟对象所需空间，分配地址
   2. 根据类加载的初始化顺序进行初始化
   3. 将内存地址返回给栈中的引用变量

   由于 Java 内存模型允许“无序写入”，有些编译器因为性能原因，可能会把上述步骤中的 2 和 3 进行重排序，顺序就成了

   1. 在堆中开辟对象所需空间，分配地址
   2. 将内存地址返回给栈中的引用变量（此时变量已不在为null，但是变量却并没有初始化完成）
   3. 根据类加载的初始化顺序进行初始化

   所以就可能会出现以下情况：

   Thread 1	Thread 2
   第一次检测， instance 为空
   获取锁
   再次检测， instance 为空
   在堆中分配内存空间
   instance 指向分配的内存空间
   	第一次检测，instance不为空
   	访问 instance（此时对象还为初始化完成）

   加入volatile关键字修饰之后，会禁用指令重排，这样就保证了线程同步。

4. 静态内部类模式(可以保证线程安全、单例唯一性、延迟单例实例化、防止指令重排)

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

   静态内部类的优点是：外部类加载时并不需要立即加载内部类，内部类不被加载则不去初始化INSTANCE，故而不占内存。即当外部类StaticSingleton第一次被加载时，并不需要去加载SingleTonHolder，只有当getInstance()方法第一次被调用时，才会去初始化INSTANCE,第一次调用getInstance()方法才会导致虚拟机加载SingleTonHolder类。这种方法不仅能确保线程安全，也能保证单例的唯一性，同时也延迟了单例的实例化。

   那么，静态内部类又是如何实现线程安全的呢？首先，我们先了解下类的加载时机。

   类加载时机：JAVA虚拟机在有且仅有的5种场景下会对类进行初始化。 1.遇到new、getstatic和setstatic或者invokestatic这4个字节码指令时，对应的java代码场景为：

   new一个关键字或一个实例化对象时、读取或设置一个静态字段时(final修饰、已在编译期把结果放入常量池的除外)、调用一个类的静态方法时。 2.使用java.lang.reflect包的方法对类进行反射调用的时候，如果类没进行初始化，需要先调用其初始化方法进行初始化。 3.当初始化一个类时，如果其父类还未进行初始化，会先触发其父类的初始化。 4.当虚拟机启动时，用户需要指定一个要执行的主类(包含main()方法的类)，虚拟机会先初始化这个类。 5.当使用JDK 1.7等动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的解析结果REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄，并且这个方法句柄所对应的类没有进行过初始化，则需要先触发其初始化。 这5种情况被称为是类的主动引用，注意，这里《虚拟机规范》中使用的限定词是"有且仅有"，那么，除此之外的所有引用类都不会对类进行初始化，称为被动引用。静态内部类就属于被动引用的行列。

   我们再回头看下getInstance()方法，调用的是SingleTonHolder.INSTANCE，取的是SingleTonHolder里的INSTANCE对象，跟上面那个DCL方法不同的是，getInstance()方法并没有多次去new对象，故不管多少个线程去调用getInstance()方法，取的都是同一个INSTANCE对象，而不用去重新创建。当getInstance()方法被调用时，SingleTonHolder才在StaticSingleton的运行时常量池里，把符号引用替换为直接引用，这时静态对象INSTANCE也真正被创建，然后再被getInstance()方法返回出去，这点同饿汉模式。那么INSTANCE在创建过程中又是如何保证线程安全的呢？在《深入理解JAVA虚拟机》中，有这么一句话:

   虚拟机会保证一个类的< clinit>()方法在多线程环境中被正确地加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的< clinit>()方法，其他线程都需要阻塞等待，直到活动线程执行< clinit>()方法完毕。如果在一个类的< clinit>()方法中有耗时很长的操作，就可能造成多个进程阻塞(需要注意的是，其他线程虽然会被阻塞，但如果执行< clinit>()方法后，其他线程唤醒之后不会再次进入< clinit>()方法。同一个加载器下，一个类型只会初始化一次。)，在实际应用中，这种阻塞往往是很隐蔽的。

   故而，可以看出INSTANCE在创建过程中是线程安全的，所以说静态内部类形式的单例可保证线程安全，也能保证单例的唯一性，同时也延迟了单例的实例化。

   那么，是不是可以说静态内部类单例就是最完美的单例模式了呢？其实不然，静态内部类也有着一个致命的缺点，就是传参的问题，由于是静态内部类的形式去创建单例的，故外部无法传递参数进去，例如Context这种参数，所以，我们创建单例时，可以在静态内部类与DCL模式里自己斟酌。

5. 枚举类实现避免反射获取(枚举类天然就是线程安全和单例的)

   

   在反射的Class对象中的newInstance方法中，如果要通过反射空参构造器获取枚举类对象，会出现如上错误

   其原理是：

   通过反编译发现，编译后的枚举类实际上的构造方法为EnumSingleDemo(String,int)

   @SuppressWarnings("all")
   public enum EnumSingleDemo {
       INSTANCE;
       public EnumSingleDemo getInstance() {
           return INSTANCE;
       }
   
       public static void main(String[] args) throws Exception {
           EnumSingleDemo instance1 = EnumSingleDemo.INSTANCE;
           //反射使用无参构造去newInstance会出现NoSuchMethodException
           Constructor<EnumSingleDemo> constructor = EnumSingleDemo.class.getDeclaredConstructor(null);
   
           //通过反编译发现,编译后的枚举类实际上的构造方法为EnumSingleDemo(String,int)
           //此时想通过反射获取对象,才会出现
           //IllegalArgumentException: Cannot reflectively create enum objects 异常
   //        Constructor<EnumSingleDemo> constructor = EnumSingleDemo.class.getDeclaredConstructor(String.class,int.class);
           constructor.setAccessible(true);
           EnumSingleDemo instance2 = constructor.newInstance(null);
           System.out.println(instance1 == instance2);
       }
   }