dictionary new一个实例_每天一个设计模式--单例模式

单例模式应该是设计模式中运用最广泛的模式之一，其目的是为了在设计层面保证某个对象有且只有一个。举个例子，一个班级只有一个班主任，有很多个学生，现在要保证每个学生都能联系到班主任，且能调用班主任对外提供的方法：比如获得期末考试分数。那么一个很简单的办法就是在每个学生对象中保存一个班主任对象，然后通过构造函数赋值。但是这样你并不能保证所有学的班主任对象都是同一个，有可能在外部new一个其他的班主任对象然后传进来。而单例模式可以很好解决这个问题。

单例模式分为几种：懒汉式、饿汉式、双重检查锁（推荐使用）、静态内部类（推荐使用）、枚举（推荐使用）。

一、懒汉式

package edu.csu.singleton.type1;

/**
 * @author yanjuefei
 * @date 2020/5/13 0013
 * @Description
 */
public class Singleton01 {
    public static void main(String[] args) {
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        System.out.println(s1 == s2);
    }
}

class Singleton {
    /**
     * 防止外部new
     */
    private Singleton() {

    }

    /**
     * 内部创建对象实例
     */
    private final static Singleton instance = new Singleton();

    /**
     * 对外提供拿到instance的接口
     * @return
     */
    public static Singleton getInstance() {
        return instance;
    }
}

优点：简单，在装载类的时候会生成实体，没有多线程问题。

缺点：如果一直没有用到这个实例，创建之后会占用资源。（实例浪费）

二、懒汉式

上面说到，在没有使用instance时如果创建，可能会早成资源浪费，很自然的想到在getInstance时，如果没有instance，那么新建一个，如果有，那就再创建。

写法一（没有synchronized，线程不安全。有synchronized，线程安全）

package edu.csu.singleton.type3;

/**
 * @author yanjuefei
 * @date 2020/5/13 0013
 * @Description
 */
public class Singleton03 {
    public static void main(String[] args) {
        System.out.println(Singleton.getInstance() == Singleton.getInstance());
    }
}
class Singleton {
    /**
     * 防止外部new
     */
    private Singleton() {

    }

    /**
     * 内部创建对象实例
     */
    private static Singleton instance;

    static {
        //在静态代码块中，创建单例对象
        instance = new Singleton();
    }

    /**
     * 对外提供拿到instance的接口
     * @return
     */
    public static (synchronized) Singleton getInstance() {
        if(instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

其实很明显，如果没有synchronized，两个线程同时进入getInstance，在if里面判断都是空的，那么两个线程会各自new 一个新对象，导致最后getInstance返回的对象不是同一个。

但是，如果每次要使用instance都要加锁，效率过低。其实我们只是在instance没有的时候才需要加锁创建，其他情况直接返回就行了，所以这个方法也不行。

三、双重检查锁（推荐使用）

首先需要在instance对象上加入volatile关键字，保证线程可见以及防止指令重排序。

如果线程AB同时进入if，判断instance是否为空，如果为空，两个线程同时试图拿锁进入synchronized代码块，但是只有一个能进入（比如A），另一个等待（比如B）。但是A完成创建之后，instance就不是null了，释放锁之后B进入，判断instance不为空，直接退出。从而保证了只有一个instance

/**
 * @author yanjuefei
 * @date 2020/5/13 0013
 * @Description
 */
public class Singleton06 {
    public static void main(String[] args) {
        System.out.println(Singleton.getInstance() == Singleton.getInstance());
    }
}

class Singleton {
    /**
     * 防止外部new
     */
    private Singleton() {

    }

    /**
     * 内部创建对象实例
     */
    private static volatile Singleton instance;

    static {
        //在静态代码块中，创建单例对象
        instance = new Singleton();
    }

    /**
     * 对外提供拿到instance的接口
     * @return
     */
    public static synchronized Singleton getInstance() {
        if(instance == null) {
            synchronized (Singleton.class) {
                if(instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

这个方法即是懒加载，又保证了线程安全

四、静态内部类（推荐使用）

package edu.csu.singleton.type7;

/**
 * @author yanjuefei
 * @date 2020/5/13 0013
 * @Description
 */
public class Singleton07 {
    public static void main(String[] args) {
        System.out.println(Singleton.getInstance() == Singleton.getInstance());
    }
}

class Singleton {
    /**
     * 防止外部new
     */
    private Singleton() {

    }

    /**
     * 写一个静态内部类，内部类有个静态属性singleton
     */
    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }
    
    /**
     * 对外提供拿到instance的接口
     * @return
     */
    public static synchronized Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

优点：

1、类加载时不会装载静态内部类（懒汉式），不会实例化instance

2、类加载时是线程安全的，只有一个进行加载，从而保证了单例。

五、枚举（最好）

当年面阿里巴巴的时候面试官问单例最好的方法是啥，我答双重检查锁，然后面试官告诉我是枚举。枚举不但能够解决多线程和懒加载，甚至还能解决反射和反序列化的问题。最为推荐。

package edu.csu.singleton.type8;

/**
 * @author yanjuefei
 * @date 2020/5/13 0013
 * @Description
 */
public class Singleton08 {
    public static void main(String[] args) {
        System.out.println(Singleton.INSTANCE == Singleton.INSTANCE);
    }
}
enum Singleton {
    /**
     * 实例
     */
    INSTANCE;
    public void sayOK() {
        System.out.println("ok");
    }
}