设计模式之单例模式

一 单例模式简介

1.1 定义

  确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。单例模式的要点有三个：

• 一是某个类只能有一个实例；
• 二是它必须自行创建这个实例；
• 三是它必须自行向整个系统提供这个实例。

  单例模式是一种对象创建型模式。单例模式又名单件模式或单态模式。

1.2 为什么要用单例模式呢？

  在我们的系统中，有一些对象其实我们只需要一个，比如说：线程池、缓存、对话框、注册表、日志对象、充当打印机、显卡等设备驱动程序的对象。事实上，这一类对象只能有一个实例，如果制造出多个实例就可能会导致一些问题的产生，比如：程序的行为异常、资源使用过量、或者不一致性的结果。

   简单来说使用单例模式可以带来下面几个好处:对于频繁使用的对象，可以省略创建对象所花费的时间，这对于那些重量级对象而言，是非常可观的一笔系统开销；由于 new 操作的次数减少，因而对系统内存的使用频率也会降低，这将减轻 GC 压力，缩短 GC 停顿时间。

1.3 为什么不使用全局变量确保一个类只有一个实例呢？

  我们知道全局变量分为静态变量和实例变量，静态变量也可以保证该类的实例只存在一个。只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。但是，如果说这个对象非常消耗资源，而且程序某次的执行中一直没用，这样就造成了资源的浪费。利用单例模式的话，我们就可以实现在需要使用时才创建对象，这样就避免了不必要的资源浪费。 不仅仅是因为这个原因，在程序中我们要尽量避免全局变量的使用，大量使用全局变量给程序的调试、维护等带来困难。

二 单例的模式的实现

• 饿汉式:指全局的单例实例在类装载时构建
• 懒汉式:指全局的单例实例在第一次被使用时构建。
  不管是那种创建方式，它们通常都存在下面几点相似处：

  单例类必须要有一个 private 访问级别的构造函数，只有这样，才能确保单例不会在系统中的其他代码内被实例化;instance 成员变量和 uniqueInstance 方法必须是 static 的。

2.1 饿汉式（线程安全）

 public class Singleton {
       //在静态初始化器中创建单例实例，这段代码保证了线程安全
        private static Singleton uniqueInstance = new Singleton();
        //Singleton类只有一个构造方法并且是被private修饰的，所以用户无法通过new方法创建该对象实例
        private Singleton(){}
        public static Singleton getInstance(){
            return uniqueInstance;
        }
    }

所谓 “饿汉式” 就是说JVM在加载这个类时就马上创建此唯一的单例实例，不管你用不用，先创建了再说，如果一直没有被使用，便浪费空间（缺点），典型的空间换时间，每次调用的时候，就不需要再判断，节省了运行时间。

2.2 懒汉式

   所谓 “ 懒汉式” 就是说单例实例在第一次被使用时构建，而不是在JVM在加载这个类时就马上创建此唯一的单例实例。

2.2.1 非线程安全和synchronized关键字线程安全版本

public class Singleton {  
      private static Singleton uniqueInstance;  
      private Singleton (){
      }   
      //没有加入synchronized关键字的版本是线程不安全的
      public static Singleton getInstance() {
          //判断当前单例是否已经存在，若存在则返回，不存在则再建立单例
          if (uniqueInstance == null) {  
              uniqueInstance = new Singleton();  
          }  
          return uniqueInstance;  
      }
}

   但是上面这种方式很明显是线程不安全的,多线程之间uniqueInstance不能保证可见性（一个线程实例化了对象，但是另外一个线程不可见，导致又去new），还有可能发生重排序， 一个对象如果多个线程同时访问getInstance()方法时就会出现问题。
如果想要保证线程安全，一种比较常见的方式就是在getInstance() 方法前加上synchronized关键字，如下：

	//效率不行，每次就一个线程能够获取实例
   public static synchronized Singleton getInstance() {  
          if (instance == null) {  
              uniqueInstance = new Singleton();  
          }  
          return uniqueInstance;  
    }  

   我们知道synchronized关键字偏重量级锁。虽然在JavaSE1.6之后synchronized关键字进行了主要包括：为了减少获得锁和释放锁带来的性能消耗而引入的偏向锁和轻量级锁以及其它各种优化之后执行效率有了显著提升。但是在程序中每次使用getInstance() 都要经过synchronized加锁这一层，这难免会增加getInstance()的方法的时间消费，而且还可能会发生阻塞。我们下面介绍到的 双重检查加锁版本 就是为了解决这个问题而存在的。

2.2.2 双重检查加锁版本

   利用双重检查加锁（double-checked locking），首先检查是否实例已经创建，如果尚未创建，“才”进行同步。这样以来，只有一次同步，这正是我们想要的效果。

public class Singleton {
    //volatile保证了可见性，当uniqueInstance不为null的时候，其他线程能够及时知道
    private volatile static Singleton uniqueInstance;
    private Singleton() {
    }
    public static Singleton getInstance() {
        if (uniqueInstance == null) {
            //这里第一次可能有多个线程同时进入这里，而且只有一个线程能够获取锁 
              //uniqueInstance 就不为null
            synchronized(Singleton.class) { // 然后用synchronized保证每次只有一个线程进入下边 
                                            //的代码
               /*当uniqueInstance 为null的时候，会进行new操作，下一个线程进入的时候就不为null（第一个null可能进入多个线程，后续这些线程也会等第一个获取锁的线程释放锁后陆陆续续也获取锁，防止后边的线程再new,所以要再判断）*/
               if (uniqueInstance == null) {
                    uniqueInstance = new Singleton();
                }
            }
        }
        return uniqueInstance;
    }
}

很明显，这种方式相比于使用synchronized关键字的方法，可以大大减少getInstance() 的时间消费。

注意： 双重检查加锁版本不适用于1.4及更早版本的Java。1.4及更早版本的Java中，许多JVM对于volatile关键字的实现会导致双重检查加锁的失效。

2.2.3 静态内部类方式

静态内部实现的单例是懒加载的且线程安全。​

/**
 * 只有通过显式调用 getInstance 方法时，才会显式装载 SingletonHolder 类，从而实例化 instance
 * 只有第一次使用这个单例的实例的时候才加载，同时不会有线程安全问题
 */
public class Singleton {
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }
    private Singleton() {
    }

    public static final Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

2.2.4 枚举方式

这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法。 它更简洁，自动支持序列化机制，绝对防止多次实例化 （如果单例类实现了Serializable接口，默认情况下每次反序列化总会创建一个新的实例对象，关于单例与序列化的问题可以查看这一篇文章《单例与序列化的那些事儿》），同时这种方式也是《Effective Java 》以及《Java与模式》的作者推荐的方式。

拓展：序列化和反序列划保证单例：重写readResolve;

public class Seriable implements Serializable {
 
 
    //序列化就是说把内存中的状态通过转换成字节码的形式
    //从而转换一个IO流，写入到其他地方(可以是磁盘、网络IO)
    //内存中状态给永久保存下来了
 
    //反序列化
    //将已经持久化的字节码内容，转换为IO流
    //通过IO流的读取，进而将读取的内容转换为Java对象
    //在转换过程中会重新创建对象new
 
 
    public  final static Seriable INSTANCE = new Seriable();
    private Seriable(){}
 
    public static  Seriable getInstance(){
        return INSTANCE;
    }
 
    private  Object readResolve(){
        return  INSTANCE;
    }
 
}

public class SeriableTest {
    public static void main(String[] args) {
 
        Seriable s1 = null;
        Seriable s2 = Seriable.getInstance();
 
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("Seriable.obj");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(s2);
            oos.flush();
            oos.close();
 
 
            FileInputStream fis = new FileInputStream("Seriable.obj");
            ObjectInputStream ois = new ObjectInputStream(fis);
            s1 = (Seriable)ois.readObject();
            ois.close();
 
            System.out.println(s1);
            System.out.println(s2);
            System.out.println(s1 == s2);
 
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
输出true,如果没有重写readResolve就为false

​ 好了，还是说正题。

public enum  Singleton {
    INSTANCE;
    public void doSome(){
        System.out.println("....");
    }
}

测试方法：

  @Test
    public void test() {
        for (int i = 0; i <= 10; i++) {
            Singleton singleton = Singleton.INSTANCE;
            System.out.println(singleton.toString());
            if (i == 2) {
                singleton.doSome();
            }
        }
    }

输出：
​​
​​

  这种方法在功能上与公有域方法相近，但是它更加简洁，无偿提供了序列化机制，绝对防止多次实例化，即使是在面对复杂序列化或者反射攻击的时候。虽然这种方法还没有广泛采用，但是单元素的枚举类型已经成为实现Singleton的最佳方法。《Java与模式》中，作者这样写道，使用枚举来实现单实例控制会更加简洁，而且无偿地提供了序列化机制，并由JVM从根本上提供保障，绝对防止多次实例化，是更简洁、高效、安全的实现单例的方式。

2.2.5 登记式

  每使用一次，都往一个固定的容器中去注册并且将使用过的对象进行缓存，下次去取对象的时候，就直接从缓存中取值，以保证每次获取的对象都是同一个对象，IOC的单例模式，就是典型的注册登记是单例

//Spring中的做法，就是用这种注册式单例
public class BeanFactory {
 
    private BeanFactory(){}
 
    //线程安全
    private static Map<String,Object> ioc = new ConcurrentHashMap<String,Object>();
 
    public static Object getBean(String className){
 
        if(!ioc.containsKey(className)){
            Object obj = null;
            try {
                obj = Class.forName(className).newInstance();
                ioc.put(className,obj);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return obj;
        }else{
            return ioc.get(className);
        }
 
    }
}