确保对象的唯一性——单例模式（五）

单例模式总结

       单例模式作为一种目标明确、结构简单、理解容易的设计模式，在软件开发中使用频率相当高，在很多应用软件和框架中都得以广泛应用。

主要优点

       单例模式的主要优点如下：

       (1) 单例模式提供了对唯一实例的受控访问。因为单例类封装了它的唯一实例，所以它可以严格控制客户怎样以及何时访问它。

       (2) 由于在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能。

       (3) 允许可变数目的实例。基于单例模式我们可以进行扩展，使用与单例控制相似的方法来获得指定个数的对象实例，既节省系统资源，又解决了单例单例对象共享过多有损性能的问题。

主要缺点

       (1) 由于单例模式中没有抽象层，因此单例类的扩展有很大的困难。

       (2) 单例类的职责过重，在一定程度上违背了“单一职责原则”。因为单例类既充当了工厂角色，提供了工厂方法，同时又充当了产品角色，包含一些业务方法，将产品的创建和产品的本身的功能融合到一起。

       (3) 现在很多面向对象语言(如Java、C#)的运行环境都提供了自动垃圾回收的技术，因此，如果实例化的共享对象长时间不被利用，系统会认为它是垃圾，会自动销毁并回收资源，下次利用时又将重新实例化，这将导致共享的单例对象状态的丢失。

       (4) 当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用new，可能会给其他开发人员造成困扰，特别是看不到源码的时候。

适用场景

       在以下情况下可以考虑使用单例模式：

       (1) 系统只需要一个实例对象，如系统要求提供一个唯一的序列号生成器或资源管理器，或者需要考虑资源消耗太大而只允许创建一个对象。

       (2) 客户调用类的单个实例只允许使用一个公共访问点，除了该公共访问点，不能通过其它途径访问该实例。

       (3) 需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多，但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象、配置文件，工具类，线程池，缓存，日志对象等。

一些补充

保证对象的唯一性：

       (1)不允许其它程序用new对象。

       因为new就是开辟新的空间，在这里更改数据只是更改所创建的对象的数据，如果可以new的话，每一次new都产生一个对象，这样肯定保证不了对象的唯一性。

       (2)在该类中创建对象

       因为不允许其它程序new对象，所以这里的对象需要在本类中new出来。

       (3)对外提供一个可以让其它程序获取该对象的方法

       因为对象是在本类中创建的，所以需要提供一个方法让其它的类获取这个对象。

如何做：

       (1)私有化该类的构造函数
       (2)通过new在本类中创建一个本类对象
       (3)定义一个公有的方法，将在该类中所创建的对象返回

单例模式各种写法及可用性

1.饿汉式（静态常量）[可用]

public class Singleton {

	private Singleton(){		
	}

	private static final Singleton INSTANCE = new Singleton();

	public static Singleton getInstance(){
		return INSTANCE ;
	}
}

//访问方式:
Singleton instance = Singleton.getInstance();

       优点：这种方式的实现比较简单，在类加载的时候就完成了实例化，避免了线程的同步问题。

       缺点：由于在类加载的时候就实例化了，所以没有达到Lazy Loading(懒加载)的效果，也就是说可能没有用到这个实例，但是它也会加载，会造成内存的浪费(但是这个浪费可以忽略，所以这种方式也是推荐使用的)。

2.饿汉式（静态代码块）[可用]

public class Singleton {

	private Singleton(){		
	}

	private static Singleton instance = null;  

    static {  
        instance = new Singleton();  
    }  

	public static Singleton getInstance(){
		return instance;
	}
}

//访问方式:
Singleton instance = Singleton.getInstance();

       其实2和1只是写法有点不同，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。它的优缺点和1一样，可以归为一种写法。

3.懒汉式（线程不安全）[不可用]

public class Singleton {

	private Singleton(){		
	}

	private static Singleton instance=null;  

	public static Singleton getInstance(){  

        if(instance==null){  
            instance=new Singleton();  
        }  
        return instance;  
    }
}

//访问方式:
Singleton instance = Singleton.getInstance();

       这种方式是在调用getInstance方法的时候才创建对象的，所以它比较懒因此被称为懒汉式。

       这种写法其实是存在线程安全问题的，起到了Lazy Loading的效果，只能在单线程下使用。在运行过程中可能存在这么一种情况：有多个线程去调用getInstance方法来获取Singleton的实例，那么就有可能发生这样一种情况，当第一个线程在执行if(instance==null)这个语句时，此时instance是为null，进入语句。在还没有执行instance=new Singleton()时(此时instance是为null的)第二个线程也进入if(instance==null)这个语句，因为之前进入这个语句的线程中还没有执行instance=new Singleton()，所以它会执行instance=new Singleton()来实例化Singleton对象，第二个线程也进入了if语句所以它也会实例化Singleton对象。这样就导致了实例化了两个Singleton对象。

4.懒汉式（线程安全，同步方法）[效率低不推荐使用]

public class Singleton {

	private Singleton(){		
	}

	private static Singleton instance=null;  

	public static synchronized Singleton getInstance(){  

        if(instance==null){  
            instance=new Singleton();  
        }  
        return instance;  
    }   
}

//访问方式:
Singleton instance = Singleton.getInstance();

       解决3实现方式的线程不安全问题，做个线程同步就可以了，于是就对getInstance()方法进行了线程同步。

       缺点：加锁这种方法效率太低了，每个线程在想获得类的实例时候，执行getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接return就行了。方法进行同步效率太低要改进。

5.懒汉式（线程不安全，同步代码块）[不可用]

public class Singleton {

	private Singleton(){		
	}

	private static Singleton instance=null;  

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

//访问方式:
Singleton instance = Singleton.getInstance();

       其实这种写法跟3一样是线程不安全的，当一个线程还没有实例化Singleton时另一个线程执行到if(instance==null)这个判断语句时就会进入if语句，虽然加了锁，但是等到第一个线程执行完instance=new Singleton()跳出这个锁时，另一个进入if语句的线程同样会实例化另外一个Singleton对象，线程不安全的原理跟3类似。因此这种改进方式并不可行。

6.双重检查[推荐用]

public class Singleton {

	private Singleton(){		
	}

	private static volatile Singleton instance=null;  

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

//访问方式:
Singleton instance = Singleton.getInstance();

       懒汉式变种，属于懒汉式中最好的写法，保证了：延迟加载和线程安全。

       Double-Check概念对于多线程开发者来说不会陌生，如代码中所示，进行了两次if (instance== null)检查，这样就可以保证线程安全了。这样，实例化代码只用执行一次，后面再次访问时，判断if (instance== null)，直接return实例化对象。
优点：线程安全；延迟加载；效率较高。

       volatile 的作用：
       即使有DCL（double checked locking）也可能会创建不止一个实例（多个类加载器，通过反射等手段生成多个对象），尽管在Java5这个问题修复了（jdk1.5在内存模型上做了大量的改善，提供了volatile关键字来修饰变量）。
       被volatile修饰的成员变量可以确保多个线程都能够正确处理，且该代码只能在JDK 1.5及以上版本中才能正确执行。由于volatile关键字会屏蔽Java虚拟机所做的一些代码优化，可能会导致系统运行效率降低，因此即使使用双重检查锁定来实现单例模式也不是一种完美的实现方式。

7.静态内部类[推荐用]

public class Singleton {

	private Singleton(){		
	}

	private static final class SingletonHolder{  
        private static Singleton INSTANCE = new Singleton();  
    }   

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

//访问方式:
Singleton instance = Singleton.getInstance();

       这种方式跟饿汉式方式采用的机制类似，但又有不同。两者都是采用了类装载的机制来保证初始化实例时只有一个线程。不同的地方在饿汉式方式是只要Singleton类被装载就会实例化，没有Lazy-Loading的作用，而静态内部类方式在Singleton类被装载时
并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingletonHolder类，从而完成Singleton的实例化。

       类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。

       这种方法被称之为Initialization Demand Holder (IoDH)的技术，通过使用IoDH，我们既可以实现延迟加载，又可以保证线程安全，不影响系统性能，不失为一种最好的Java语言单例模式实现方式，其缺点是与编程语言本身的特性相关，很多面向对象语言不支持IoDH。

8.枚举[极推荐使用]

public enum SingletonEnum {  

     INSTANCE;   

     public void method(){  

     }  
}  

//访问方式:
SingletonEnum.INSTANCE.method();

       可以看到枚举的书写非常简单，访问也很简单。枚举单例有序列化和线程安全的保证，而且只要几行代码就能实现，是单例最好的的实现方式。在这里SingletonEnum.INSTANCE，这里的INSTANCE即为SingletonEnum类型的引用，所以得到它就可以调用枚举中的方法了。

       借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。可能是因为枚举在JDK1.5中才添加，所以在实际项目开发中，很少见人这么写过，这种方式也是最好的一种方式，如果在开发中JDK满足要求的情况下建议使用这种方式。

       在真正的项目开发中一般采用1、6、7、8，一般情况下这几种模式是没有问题的，多数人一般采用6这种写法，我们经常用的Android-Universal-Image-Loader这个开源项目也是采用的6这种写法，其实最安全的写法是8即枚举，它的实现非常简单而且最安全可谓很完美，但可能是因为只支持JDK1.5又或者是因为枚举大家不熟悉，所以目前使用的人并不多，但可以尝试下。另外当我们使用反射机制时可能不能保证实例的唯一性，但是枚举始终可以保证唯一性，但是一般情况下很少遇到这种情况。

参考资料：
LoveLion 确保对象的唯一性——单例模式 （五）
OpenFire 单例模式的八种写法比较