单例模式详细分析&7种实现方式

      随风摇摆，好还是不好？

        这次给大家带来对单例模式的学习，单例模式是设计模式中最简单的存在。在很多应用场景中，需要系统能够提供一个可供所有对象调用，提供统一功能接口，但又不会频繁的创建和销毁对象，导致效率低下的单例类。

        单例模式用途广泛，确保系统中只会有一个实例，无论什么对象调用都是这个实例，类似打印机工作，线程池，日志对象，显卡驱动，对话框等都被设计成单例。

        单例模式的一个重要特征是，系统中只会存在一个实例，如何保证系统中只会存在一个实例呢，一个简单的办法是创建一个全局变量，但在java中全局变量一般被设置成static，其他实例可以直接访问，同样的也可以通过实例化多个对象可以获取这个定义的全局变量，不同对象占用不同内存空间，无法保证系统中只有一个对象，好的办法是生成实例的操作封装在单例类自身，每个对象调用都需要通过，单例类提供的接口外部无法通过实例化多个对象获取单例类的对象。

所以单例模式特点如下：

    1、单例类只能有一个实例。

    2、单例类必须自己创建自己的唯一实例。

    3、单例类必须给所有其他对象提供这一实例。

单例模式的uml类图：

Singleton类包括一个私有的构造函数和本身的一个静态实例。

Singleton 类提供了一个静态方法，供外界获取它的静态实例。

单例模式的创建方法很多种，今天给大家带来7种实现方式（java语言），jdk1.7。

1、懒汉式，线程不安全

        最基本的单例实现方式，实现了延迟加载功能，不为空时才new 新的对象，这种方式延迟加载（ lazy loading） 很明显，没有实例化类时就创建对象。构造方法是私有的，避免了外部调用，只能通过内部提供的静态方法获取对象。

 但多线程模式下存在问题，可能在new对象时产生同步问题，可能会产生多个单例对象。

class Singleton1{

   publicstatic Singleton1 instance;

   private Singleton1(){

   }

   public  static Singleton1 getInstance(){


      if (instance==null) {//存在并发问题可能产生多个对象

         instance=new Singleton1();

      }

      returninstance;

   }
}

2、懒汉式，线程安全

这种单例实现方式对普通的懒汉模式进行优化，添加了synchronized关键字进行同步，此处对Singleton2对象添加锁，第一次调用才初始化，不存在同步问题，避免内存浪费，具备很好的 lazy loading。但很多时候不需要进行同步，每次加载对象，都会进行同步，严重影响效率，现实中很少使用。

class Singleton2{

   publicstatic Singleton2 instance;

   private Singleton2(){
 
   }

   public  staticsynchronized Singleton2 getInstance(){
      if (instance==null) {

         instance=new Singleton2();

      }
      returninstance;
   }
}

3、饿汉式

     这种实现方式比较常用，基于classloader机制避免了多线程的同步问题，字段只会实例化一次，所以天生是线程安全的，没有加锁执行效率会提高。但类加载时就初始化，虽然在单例模式中大多数都是调用getInstance方法，但是也不能确定有其他的方式导致类装载，这时候初始化instance显然没有达到lazy loading的效果。导致实例化的原因很多，加载静态方法时也会导致不必要的加载。

class Singleton3{

   public static Singleton3 instance=new Singleton3();

   private Singleton3(){
   }

   public  static Singleton3 getInstance(){
      returninstance;
   }
}

4 恶汉变种

恶汉变种每次实例化是才会调用，添加静态代码快，第一次实例化时才会调用，其实是第三种的另外一种写法，没什么特别的。

class Singleton4{

   privatestatic  Singleton4 instance=null;

   static{
       instance=newSingleton4();
   }

 private Singleton4(){
   }

   public  static Singleton4 getInstance(){
      returninstance;

   }
}

 

5 双重锁检查机制

      这个是第二种方式的升级版，俗称双重检查锁定，双重检查 DCL，这种方式只有jdk1.5以后才支持，安全且在多线程情况下能保持高性能。

    注意到instance 字段添加了volatile关键字，此关键字使得对于instance修改后最终的值,会被其他线程看到，不会再cpu本地内存中，会直接作用到主存中。否则双重判断依然存在问题，因为一个变量的生成不是一个原子操作，首先分配内存空间，然后将内存空间的地址赋值给对应的引用，初始化对象，这个过程可能会发生重排序，极有可能最后返回的对象是个空对象，volatile关键字禁止了内存的重排序，不会出现第二个过程排在第三个过程后面的情况。在getInstance中做了两次null检查，确保了只有第一次调用单例的时候才会做同步，这样也是线程安全的，同时避免了每次都同步的性能损耗

class Singleton6{

   privatevolatilestatic Singleton6 instance=null;

   private Singleton6(){

   }

   public  static Singleton6 getInstance(){
      if (instance==null) {

         synchronized (Singleton6.class) {

            if (instance==null) {

                 instance=newSingleton6();

            }

         }

      }

      returninstance;

   }

}

 

6、静态内部类生成单例方式

      这种实现方式可以实现双检锁方式一样的效果，但实现更简单。对静态域使用延迟初始化，应使用这种方式而不是双检锁方式。这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用。

        利用了 classloder机制来保证初始化instance时只有一个线程，它跟第 3种方式不同的是：第 3种方式只要 Singleton类被装载了，那么 instance就会被实例化，而这种方式是Singleton类被装载了，instance不一定被初始化。因为 SingletonHolder类没有被主动使用，只有显示通过调用 getInstance方法时，才会显示装载SingletonHolder类，从而实例化 instance。如果实例化 instance很消耗资源，想让它延迟加载，另外一方面，又不希望在Singleton类加载时就实例化，因为不能确保 Singleton类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化 instance显然是不合适的。这个时候，这种方式相比第3种方式就显得很合理。

class Singleton5{
   private static class  SingletonHolder{
  public static final  Singleton5 instance=new Singleton5();
   }
   private Singleton5(){
   }
   public  static Singleton5 getInstance(){

      return SingletonHolder.instance;

   }

}

7、枚举方式

描述：这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。不过，由于 JDK1.5之后才加入 enum特性，用这种方式写不免让人感觉生疏，在实际工作中，也很少用。

public enum Singleton { 

   INSTANCE; 

   public void instanceMethod() { 

   } 

}  

一般情况下，不建议使用第 1 种和第 2 种懒汉方式，建议使用第 3,4 种饿汉方式。只有在要明确实现 lazy loading 效果时，才会使用第6 种登记方式。如果涉及到反序列化创建对象时，可以尝试使用第7 种枚举方式。如果有其他特殊的需求，可以考虑使用第5 种双检锁方式。