Design Pattern —— Singleton

Design Pattern —— Singleton   强力推荐枚举和类级内部类方式实现单例模式

单例模式是开发中非常常用的一种模式，简单的说，我们希望一个类永远都只有一个对象。

主要有两个用途：

1.存储一些进程内共享的值（不是很推荐，大部分情况下还是应该用局部变量，互相传递值的方式）

2.任何时候都不变的操作

单例模式的实现目前已知的有五种：

1.饿汉式

2.懒汉式

3.双重验证

4.类级内部类

5.枚举

一、饿汉式

类加载时就创建好对象，以空间换时间。这样外部调用EagerSingleton.getInstance()时，直接获得这个创建好的对象。

 public class EagerSingleton {
     private static EagerSingleton instance = new EagerSingleton();
     /**
      * 私有默认构造子
      */
     private EagerSingleton(){}
     /**
      * 静态工厂方法
      */
     public static EagerSingleton getInstance(){
         return instance;
     }
 }

优点：节省运行时间

缺点：占用空间

二、懒汉式

类加装时不创建对象，直到需要使用时才创建。

 public class LazySingleton {
     private static LazySingleton instance = null;
     /**
      * 私有默认构造子
      */
     private LazySingleton(){}
     /**
      * 静态工厂方法
      */
     public static synchronized LazySingleton getInstance(){
         if(instance == null){
             instance = new LazySingleton();
         }
         return instance;
     }
 }

优点：节省空间，如果一直不用，就不会创建

缺点：每次获取实例都会进行判断，看是否需要创建实例，浪费判断的时间。且是由于是线程安全的，所以会降低整体的访问速度

三、双重验证

双重验证的单例模式，是懒汉式单例的一种优化方式。既实现线程安全，又能够使性能不受很大的影响。

定义：

1.先不同步，进入方法后，先检查实例是否存在，如果不存在才进行下面的同步块，这是第一重检查；

2.进入同步块过后，再次检查实例是否存在，如果不存在，就在同步的情况下创建一个实例，这是第二重检查。

这样一来，就只需要同步一次了，从而减少了多次在同步情况下进行判断所浪费的时间。

　　“双重检查加锁”机制的实现会使用关键字volatile，简单的说：被volatile修饰的变量的值，将不会被本地线程缓存，所有对该变量的读写都是直接操作共享内存，从而确保多个线程能正确的处理该变量。

 public class Singleton {
     private volatile static Singleton instance = null;
     private Singleton(){}
     public static Singleton getInstance(){
         //先检查实例是否存在，如果不存在才进入下面的同步块
         if(instance == null){
             //同步块，线程安全的创建实例
             synchronized (Singleton.class) {
                 //再次检查实例是否存在，如果不存在才真正的创建实例
                 if(instance == null){
                     instance = new Singleton();
                 }
             }
         }
         return instance;
     }
 }

双重验证的方式虽然看上去很美，但是是不被推荐使用的。具体volatile的使用也是一个比较大的课题，有一篇非常好的文章推荐http://www.cnblogs.com/dolphin0520/p/3920373.html

四、类级内部类实现的方式。

那我们能不能想到一个办法，既让第一次使用时才创建对象，又解决线程安全呢。

类级内部类的特点：

1.类级内部类的对象和外部类对象没有依赖关系

2.类级内部类中可以有静态方法，此静态方法只能调用外部类的静态方法和成员变量

3.类级内部类只有在第一次使用时才会加载

JVM在有些时候会隐式的去执行同步操作：

1.由静态初始化器（在静态字段上或static{}块中的初始化器）初始化数据时

2.访问final字段时

3.在创建线程之前创建对象时

4.线程可以看见它将要处理的对象时

实现线程安全：可以采用静态初始化器的方式，它可以由JVM来保证线程的安全性。

实现延迟加载：采用类级内部类，在这个类级内部类里面去创建对象实例。只要不使用到这个类级内部类，那就不会创建对象实例。

 public class Singleton {

     private Singleton(){}
     /**
      *    类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例
      *    没有绑定关系，而且只有被调用到时才会装载，从而实现了延迟加载。
      */
     private static class SingletonHolder{
         /**
          * 静态初始化器，由JVM来保证线程安全
          */
         private static Singleton instance = new Singleton();
     }

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

五、枚举实现单例

《effectJava》一书中重点推荐的实现单例的方式

 public enum Singleton {
     /**
      * 定义一个枚举的元素，它就代表了Singleton的一个实例。
      */

     uniqueInstance;

     /**
      * 单例可以有自己的操作
      */
     public void singletonOperation(){
         //功能处理
     }
 }

枚举单例，简洁，提供序列化机制，防止多实例化，防止反射，是实现单例的最佳方案。

参考资料

http://www.cnblogs.com/dolphin0520/p/3920373.html  violate详解

http://www.cnblogs.com/java-my-life/archive/2012/03/31/2425631.html  java与模式之单例模式

《effectJava》