7种单例模式设计
阅读《Java高并发编程详解》后的笔记。
1、饿汉式：
/**
* 饿汉式
* 若一个类的成员都是比较重的资源，这种方式不合适
*/
//不允许被继承
public final class Singleton {
//定义实例变量的时候直接初始化
//instance被ClassLoader 加载后很长一段时间才被使用，它所开辟的堆内存会驻留更久
private static Singleton instance = new Singleton();
//私有构造函数，不允许外部new
private Singleton(){
}
//无法进行懒加载
public static Singleton getInstance(){
return instance;
}
}以上代码中instance作为类变量在初始化的过程中会被收集进
2、懒汉式：
/**
* 懒汉式
* 实用类实例变量的时候再去创建
*/
public final class Singleton {
//定义实例,不初始化
private static Singleton instance = null;
//私有构造函数，不允许外部new
private Singleton(){
}
//可保证实例的懒加载，但无法保证实例的唯一性
public static Singleton getInstance(){
if(null == instance)
instance = new Singleton();
return instance;
}
}
以上代码中Singleton.class被初始化时instance并没有被实例化，getInstance()会判断instance是否被实例化，但是放在多线程的环境下进行分析，若有两个线程同时看到instance为null，那么instance将无法保证单例的唯一性。
3、懒汉式+同步方法
/**
* 懒汉式+同步方法
*
*/
public final class Singleton {
//定义实例,不初始化
private static Singleton instance = null;
//私有构造函数，不允许外部new
private Singleton(){
}
//向getInstance()加入同步控制，每次只能有一个线程进入
public static synchronized Singleton getInstance(){
if(null == instance)
instance = new Singleton();
return instance;
}
}这里instance其实就是共享资源（数据），当多个线程访问时，需要保证数据的同步性，这种方式满足了懒加载又能保证instance实例的唯一性，但是synchronized的排他性导致getInstance()只能在同一时刻被一个线程访问，性能地下。
4、Double-Check
/**
* Double-Check
* 高效的数据同步策略，首次初始化时加锁，之后允许多个线程同时进行getInstance调用来获得实例
*/
public final class Singleton {
//定义实例,不初始化
private static Singleton instance = null;
Connection conn;
Socket socket;
//私有构造函数，不允许外部new
private Singleton(){
this.conn;//初始化conn
this.socket;//初始化socket
}
public static Singleton getInstance(){
//当instance为null时，进入同步代码块，同时可避免了每次都需要进入同步代码块，可提高效率
if(null == instance) {
synchronized (Singleton.class){
//判断如果instance为null时创建
if(null == instance){
instance = new Singleton();
}
}
}
return instance;
}
}当有两个线程发现null==instance成立时，只有一个线程有资格进入同步代码块，完成对instance的实例化，随后的线程发现null==instance不成立则不进行任何动作，以后对getInstance的访问就不需要数据同步保护了。
这种方法既满足了懒加载，又保证了instance实例的唯一性，可以允许多个线程同时对getInstance进行访问，但在多线程的情况下可能会引起空指针。
原因：
5、volatile+Double-Check
/**
* volatile+Double-Check
* 高效的数据同步策略,volatile可以防止指令重排序
*/
public final class Singleton {
//定义实例,不初始化
private volatile static Singleton instance = null;
//私有构造函数，不允许外部new
private Singleton(){
}
public static Singleton getInstance(){
//当instance为null时，进入同步代码块，同时可避免了每次都需要进入同步代码块，可提高效率
if(null == instance) {
synchronized (Singleton.class){
//判断如果instance为null时创建
if(null == instance){
instance = new Singleton();
}
}
}
return instance;
}
}这种方式满足多线程下的单例、懒加载以及获取实例的高效性。
6、Holder方式
/**
* Holder方式
* 借助类加载的特点，单例设计的最好方式之一
*/
public final class Singleton {
//私有构造函数，不允许外部new
private Singleton(){
}
//在静态内部类中持有Singleton的实例，并且可直接被初始化
private static class Holder{
private static Singleton instance = new Singleton();
}
//调用getInstance方法，事实上获得Holder的instance静态属性
public static Singleton getInstance(){
return Holder.instance;
}
}在Singleton初始化的过程中不会创建Singleton的实例，静态内部类Holder中定义了Singleton的静态变量，并直接实例化，当Holder被主动引用时会创建Singleton的实例，Singleton实例的创建在Java编译时期收集在
7、枚举方式
/**
* 枚举方式
* 枚举类型不允许被继承，同时是线程安全且只能被实例化一次
*
*/
public enum Singleton {
INSTANCE;
Singleton(){
System.out.println("INSTANCE will be initialized immediately");
}
private static void method(){
//调用该方法会主动使用Singleton,INSTANCE将会被实例化
}
//调用getInstance方法，事实上获得Holder的instance静态属性
public static Singleton getInstance(){
return INSTANCE;
}
}枚举类型不允许被继承，同时是线程安全且只能被实例化一次，但是枚举类型不能够懒加载，对Singleton主动使用，如滴啊用其中的静态方法INSTANCE会立即实例化，可对其进行改造，增加懒加载的特性，类似于Holder方式：
/**
* 类似于Holder方式
* 枚举类型不允许被继承，同时是线程安全且只能被实例化一次
*
*/
public class Singleton{
private Singleton(){
}
//使用枚举充当holder
private enum EnumHolder {
INSTANCE;
private Singleton instance;
EnumHolder(){
this.instance = new Singleton();
}
public Singleton getSingleton(){
return instance;
}
}
public static Singleton getInstance(){
return EnumHolder.INSTANCE.getSingleton();
}
}