【设计模式】单例

 单例模式（Singleton Pattern）是 Java 中名气最大的设计模式。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。什么是创建型模式？请看下图

组件的生命周期分为4个阶段的话，那么单例就属于组件的创建阶段的一种模式。

应用实例：

方式1：懒汉式，线程不安全

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

解析：懒汉，你什么时候需要，我什么时候创建，但是多线程环境下不安全

方式2：懒汉式，线程安全

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

解析：其实就是方式1加同步锁，解决了并发问题，但是如此一来效率极低，试想一下，每一个请求调用getInstance() 都需要现货区同步锁，意思我无论是不是并发都要获取一下锁，这样效率极低

方式3：饿汉式（线程安全）

public class Singleton {  
    private static Singleton instance = new Singleton();  
    private Singleton (){}  
    public static Singleton getInstance() {  
    return instance;  
    }  
}

解析：类装载的时候就初始化，这样保证了单例，但是会产生很多垃圾对象

方式4：双检锁/双重校验锁（效率高，实现复杂，多线程安全）

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

解析：双重校验如此优秀地实现了单例，重点在于以下

1、新增一次空校验，sync同步代码块放在两次判断中间：

不为空可以直接跳过加锁操作，为空才会进行加锁，大大节省程序运行时间。

若线程1和线程2同时被加锁等待，当线程1加锁后跳过第二个判断创建了对象，线程2放行进入同步代码块需要在判空一下，这就是二次哦按段的必要性。

2、volatile 内存可见性：

①保证可见性。使用 volatile定义的变量，将会保证对所有线程的可见性。

②禁止指令重排序优化（分配内存、变量赋值和初始化对象可能会发生重排）

方式5：登记式/静态内部类

public class Singleton {  
    private static class SingletonHolder {  
    private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
    return SingletonHolder.INSTANCE;  
    }  
}