设计模式之单例模式

一. 概述

单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一类只有一个实例而且该实例易于外界访问，从而达到使用目的（如windows操作系统中，任务管理器只能打开一个–主要目的），同时还能方便对实例个数的控制并节约系统资源（主要目的之外的好处）。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。

二.八种实现方式
1）饿汉式（静态常量）
2）饿汉式（静态代码块）
3）懒汉式（线程不安全）
4）懒汉式（线程安全，同步方法）
5）懒汉式（线程不安全，同步代码块）
6）懒汉式（Double Check 线程安全，效率高）
7）静态内部类
8）枚举

//单例一种比较重要的一步私有化构造器

---

1）饿汉式（静态常量）
原因：static修饰的变量，当类第一次加载时就会初始化
当Singleton instance = Singleton.getInstance();时，
代码执行顺序为
一、private final static Singleton instance = new Singleton();
二、public static Singleton getInstance(){
return instance;
}
然后 Singleton instance2 = Singleton.getInstance();时直接执行
public static Singleton getInstance(){
return instance;
}
这里用 private 修饰 Singleton() 防止new 创建Singleton类（不创建就不会被覆盖），这样instance（对象）就会一直存在于缓冲区（JVM类加载机制）
static修饰的变量，可以通过类名.方法名直接获取

public class Singleton01 {

    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);
    }


}
class Singleton{

    //1.构造器私有化，外部不能new   
    private Singleton(){

    }
    //2.本类内部创建对象实例
    private final static Singleton instance = new Singleton();

    //3.提供一个公有的静态方法，返回实例对象
    public static Singleton getInstance(){
        return instance;
    }

}

2）饿汉式（静态代码块）
原因：和方式1）基本相同，静态代码块在类加载的时候也会加载，static修饰都是在类加载的时候进行第一次初始化（当然后面也可以能被修改，这里能保证不被修改）

饿汉式的缺点是浪费资源，有的时候不需要，但是类加载就会生成，类加载的情况有很多

package test01;

public class Singleton02 {

    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);
    }

}

class Singleton{
    //1.构造器私有化，外部不能new   
    private Singleton(){

    }

    //2.本类内部创建对象实例
    private final static Singleton instance;

    static {
         instance = new Singleton();
    }

    //3.提供一个公有的静态方法，返回实例对象
    public static Singleton getInstance(){
        return instance;
    }

}

3）懒汉式（线程不安全）
每次调用getInstance（）方法，判断instance是否为null，如果为空new Singleton（），不为空则直接返回创建好的
为什么线程不安全，例如线程A正在执行new Singleton（）还没有给instance赋值，这时线程B进行（instance ==null)的条件是成立的，B也就通过了条件判断，会进行两次new Singleton（）操作

public class SingletonTest03 {


    public static void main(String[] args) {

        System.out.println("懒汉式，线程不安全");

        Singleton singleton = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();

        System.out.println(singleton == singleton2);

    }

}

class Singleton{
    private static Singleton instance;


    private Singleton(){

    }

    //提供一个静态的公共方法，当使用到该方法时，才去创建instance，所有也称懒汉式

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

    }

}

4）懒汉式（线程安全，同步方法）

synchronized 修饰的方法体只能有一个线程操作该方法体，所以不存在方式3的情况，不过效率很低

public class SingletonTest03 {


    public static void main(String[] args) {

        System.out.println("懒汉式，线程安全");

        Singleton singleton = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();

        System.out.println(singleton == singleton2);

    }

}

class Singleton{
    private static Singleton instance;


    private Singleton(){

    }

    //提供一个静态的公共方法，当使用到该方法时，才去创建instance，所有也称懒汉式

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

    }

}

5）懒汉式（线程不安全，同步代码块）

为什么线程不安全，虽然synchronized修饰Singleton.class，但是他并不是在类刚开始加载时就被锁起来了，
也有可能因为指令重排导致线程不安全问题

不过这个安全问题出现的可能性还是极低的

public class SingletonTest03 {


    public static void main(String[] args) {

        System.out.println("懒汉式，不线程安全");

        Singleton singleton = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();

        System.out.println(singleton == singleton2);

    }

}

class Singleton{
    private static Singleton instance;

    private Singleton(){

    }

    //提供一个静态的公共方法，当使用到该方法时，才去创建instance，所有也称懒汉式

    public  static Singleton getInstance(){
        if (instance == null){

            synchronized (Singleton.class){
                instance = new Singleton();
            }
        }
        return instance;
    }

}

6）懒汉式（Double Check 线程安全，效率高）
这个应该时面试官最喜欢问的，最重要的实现方式

这个以前写过，这里就不写了，下面有连接
并发编程之volatile

public class Singleton {  
    private volatile static Singleton singleton;  
    private Singleton (){}  
    public static Singleton getSingleton() {  
     // 实例没创建，才会进入内部的 synchronized代码块
    if (singleton == null) {  
        synchronized (Singleton.class) {  
       // 也许有其它线程已经创建实例，所以再判断一次
        if (singleton == null) {  
            singleton = new Singleton();  
        }  
        }  
    }  
    return singleton;  
    }  
}

7）静态内部类

public class SingleTon{
  private SingleTon(){}
 
  private static class SingleTonHoler{
     private static SingleTon INSTANCE = new SingleTon();
 }
 
  public static SingleTon getInstance(){
    return SingleTonHoler.INSTANCE;
  }
}

下面内容借鉴于：
静态内部类的优点是：外部类加载时并不需要立即加载内部类，内部类不被加载则不去初始化INSTANCE，故而不占内存。即当SingleTon第一次被加载时，并不需要去加载SingleTonHoler，只有当getInstance()方法第一次被调用时，才会去初始化INSTANCE,第一次调用getInstance()方法会导致虚拟机加载SingleTonHoler类，这种方法不仅能确保线程安全，也能保证单例的唯一性，同时也延迟了单例的实例化。

那么，静态内部类又是如何实现线程安全的呢？首先，我们先了解下类的加载时机。

类加载时机：JAVA虚拟机在有且仅有的5种场景下会对类进行初始化。
1.遇到new、getstatic、setstatic或者invokestatic这4个字节码指令时，对应的java代码场景为：new一个关键字或者一个实例化对象时、读取或设置一个静态字段时(final修饰、已在编译期把结果放入常量池的除外)、调用一个类的静态方法时。
2.使用java.lang.reflect包的方法对类进行反射调用的时候，如果类没进行初始化，需要先调用其初始化方法进行初始化。
3.当初始化一个类时，如果其父类还未进行初始化，会先触发其父类的初始化。
4.当虚拟机启动时，用户需要指定一个要执行的主类(包含main()方法的类)，虚拟机会先初始化这个类。
5.当使用JDK 1.7等动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的解析结果REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄，并且这个方法句柄所对应的类没有进行过初始化，则需要先触发其初始化。
这5种情况被称为是类的主动引用，注意，这里《虚拟机规范》中使用的限定词是"有且仅有"，那么，除此之外的所有引用类都不会对类进行初始化，称为被动引用。静态内部类就属于被动引用的行列。

我们再回头看下getInstance()方法，调用的是SingleTonHoler.INSTANCE，取的是SingleTonHoler里的INSTANCE对象，跟上面那个DCL方法不同的是，getInstance()方法并没有多次去new对象，故不管多少个线程去调用getInstance()方法，取的都是同一个INSTANCE对象，而不用去重新创建。当getInstance()方法被调用时，SingleTonHoler才在SingleTon的运行时常量池里，把符号引用替换为直接引用，这时静态对象INSTANCE也真正被创建，然后再被getInstance()方法返回出去，这点同饿汉模式。那么INSTANCE在创建过程中又是如何保证线程安全的呢？在《深入理解JAVA虚拟机》中，有这么一句话:

虚拟机会保证一个类的()方法在多线程环境中被正确地加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的()方法，其他线程都需要阻塞等待，直到活动线程执行()方法完毕。如果在一个类的()方法中有耗时很长的操作，就可能造成多个进程阻塞(需要注意的是，其他线程虽然会被阻塞，但如果执行()方法后，其他线程唤醒之后不会再次进入()方法。同一个加载器下，一个类型只会初始化一次。)，在实际应用中，这种阻塞往往是很隐蔽的。

故而，可以看出INSTANCE在创建过程中是线程安全的，所以说静态内部类形式的单例可保证线程安全，也能保证单例的唯一性，同时也延迟了单例的实例化。

那么，是不是可以说静态内部类单例就是最完美的单例模式了呢？其实不然，静态内部类也有着一个致命的缺点，就是传参的问题，由于是静态内部类的形式去创建单例的，故外部无法传递参数进去，例如Context这种参数，所以，我们创建单例时，可以在静态内部类与DCL模式里自己斟酌。

8）枚举

public enum SingleTon{
  INSTANCE;
        public void method(){
        //TODO
     }
}

枚举在java中与普通类一样，都能拥有字段与方法，而且枚举实例创建是线程安全的，在任何情况下，它都是一个单例。我们可直接以

SingleTon.INSTANCE