单例模式

单例模式的要点：

1.延迟加载

2.线程安全

3.序列化与反序列化

饿汉法

顾名思义，饿汉法就是在第一次引用该类的时候就创建对象实例，而不管实际是否需要创建。代码如下：

1 2 3 4 5 6 7

public  class  Singleton {        private  static  Singleton = new  Singleton();      private  Singleton() {}      public  static  getSignleton(){          return  singleton;      } }

这样做的好处是编写简单，但是无法做到延迟创建对象。但是我们很多时候都希望对象可以尽可能地延迟加载，从而减小负载，所以就需要下面的懒汉法：

单线程写法

这种写法是最简单的，由私有构造器和一个公有静态工厂方法构成，在工厂方法中对singleton进行null判断，如果是null就new一个出来，最后返回singleton对象。这种方法可以实现延时加载，但是有一个致命弱点：线程不安全。如果有两条线程同时调用getSingleton()方法，就有很大可能导致重复创建对象。

1 2 3 4 5 6 7 8

public  class  Singleton {      private  static  Singleton singleton = null ;      private  Singleton(){}      public  static  Singleton getSingleton() {          if (singleton == null ) singleton = new  Singleton();          return  singleton;      } }

考虑线程安全的写法

这种写法考虑了线程安全，将对singleton的null判断以及new的部分使用synchronized进行加锁。同时，对singleton对象使用volatile关键字进行限制，保证其对所有线程的可见性，并且禁止对其进行指令重排序优化。如此即可从语义上保证这种单例模式写法是线程安全的。注意，这里说的是语义上，实际使用中还是存在小坑的，会在后文写到。

1 2 3 4 5 6 7 8 9 10 11 12 13 14

public  class  Singleton {      private  static  volatile  Singleton singleton = null ;         private  Singleton(){}         public  static  Singleton getSingleton(){          synchronized  (Singleton. class ){              if (singleton == null ){                  singleton = new  Singleton();              }          }          return  singleton;      }    }

兼顾线程安全和效率的写法

虽然上面这种写法是可以正确运行的，但是其效率低下，还是无法实际应用。因为每次调用getSingleton()方法，都必须在synchronized这里进行排队，而真正遇到需要new的情况是非常少的。所以，就诞生了第三种写法：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

public  class  Singleton {      private  static  volatile  Singleton singleton = null ;            private  Singleton(){}            public  static  Singleton getSingleton(){          if (singleton == null ){              synchronized  (Singleton. class ){                  if (singleton == null ){                      singleton = new  Singleton();                  }              }          }          return  singleton;      }    }

这种写法被称为“双重检查锁”，顾名思义，就是在getSingleton()方法中，进行两次null检查。看似多此一举，但实际上却极大提升了并发度，进而提升了性能。为什么可以提高并发度呢？就像上文说的，在单例中new的情况非常少，绝大多数都是可以并行的读操作。因此在加锁前多进行一次null检查就可以减少绝大多数的加锁操作，执行效率提高的目的也就达到了。

静态内部类法

那么，有没有一种延时加载，并且能保证线程安全的简单写法呢？我们可以把Singleton实例放到一个静态内部类中，这样就避免了静态实例在Singleton类加载的时候就创建对象，并且由于静态内部类只会被加载一次，所以这种写法也是线程安全的：

1 2 3 4 5 6 7 8 9 10 11

public  class  Singleton {      private  static  class  Holder {          private  static  Singleton singleton = new  Singleton();      }            private  Singleton(){}                public  static  Singleton getSingleton(){          return  Holder.singleton;      } }

但是，上面提到的所有实现方式都有两个共同的缺点：

• 都需要额外的工作(Serializable、transient、readResolve())来实现序列化，否则每次反序列化一个序列化的对象实例时都会创建一个新的实例。因为传统的单例模式的另外一个问题是一旦你实现了serializable接口，他们就不再是单例的了，因为readObject()方法总是返回一个 新的实例对象，就像java中的构造器一样。就是每次反序列化一个序列化的实例时，都会创建一个新的实例。为了防止这种情况，要在类中加入readResolve方法。

• 可能会有人使用反射强行调用我们的私有构造器（如果要避免这种情况，可以修改构造器，让它在创建第二个实例的时候抛异常）。

枚举写法

当然，还有一种更加优雅的方法来实现单例模式，那就是枚举写法：

1 2 3 4 5 6 7 8 9 10

public  enum  Singleton {      INSTANCE;      private  String name;      public  String getName(){          return  name;      }      public  void  setName(String name){          this .name = name;      } }

使用枚举除了线程安全和防止反射强行调用构造器之外，还提供了自动序列化机制，防止反序列化的时候创建新的对象。因此，Effective Java推荐尽可能地使用枚举来实现单例。

另一个实现：

class Resource{
}

public enum SomeThing {
    INSTANCE;
    private Resource instance;
    SomeThing() {
        instance = new Resource();
    }
    public Resource getInstance() {
        return instance;
    }
}

===========================

枚举为什么提供序列化机制？

就拿枚举来说，其实Enum就是一个普通的类，它继承自 java.lang.Enum类。

public   enum  DataSourceEnum {

    DATASOURCE;

}  

把上面枚举编译后的字节码反编译，得到的代码如下：

public final class DataSourceEnum extends Enum<DataSourceEnum> {

      public static final DataSourceEnum DATASOURCE;

      public static DataSourceEnum[] values();

      public static DataSourceEnum valueOf(String s);

      static {};

}

由反编译后的代码可知， DATASOURCE  被声明为  static  的， 根据 在 【单例深思】饿汉式与类加载 中所描述的类加载过程，可以知道 虚拟机会保证一个类的 <clinit>()  方法在多线程环境中被正确的加锁、同步。所以，枚举 实现是在 实例化时是线程安全 。

接下来看看序列化问题：

Java规范中规定， 每一个枚举类型极其定义的枚举变量在JVM中都是唯一的，因此在枚举类型的序列化和反序列化上，Java做了特殊的规定。

在序列化的时候Java仅仅是将枚举对象的name属性输出到结果中，反序列化的时候则是通过 java.lang.Enum 的 valueOf() 方法来根据名字查找枚举对象。

也就是说，以下面枚举为例，序列化的时候只将  DATASOURCE  这个名称输出，反序列化的时候再通过这个名称，查找对于的枚举类型，因此反序列化后的实例也会和之前被序列化的对象实例相同。