单例模式的8种写法

这篇文章中我会用8种写法来对单例模式进行优化

但是说实话在平常我们进行代码编写的时候用不着那么完美

第一种写法

饿汉式：

　　优点：简单实用

　　缺点：不论该对象是否会被用到，都提前将对象实例化

1.首先我们创建出一个静态的不可更改的变量Instance

2.我们将该类的构造方法的权限设置为private，防止其他类new对象

3.设置该对象的get方法

/**
 * 饿汉式
 * 类加载到内存后，就实例化一个单例，JVM保证线程安全
 * (JVM保证每一个class只会露到内存一次，那么static变量在class露到内存之后马上进行初始化，所以static变量也保证初始化这一次)
 * 简单实用，推荐使用
 * 唯一缺点：不管用到与否，类加载时就完成实例化
 */
public class Mgr01 {
    private static final Mgr01 Instance = new Mgr01();

    private Mgr01(){}

    public static Mgr01 getInstance(){return Instance;}

    public static void main(String[] args) {
        /**
         * 调用静态方法常用的两种方式
         *   1.new对象调用静态方法
         *   2.类名打点调用静态方法
         *   这里构造方法设为私有访问控制符，不能new对象
         */
        Mgr01 m1 = Mgr01.getInstance();
        Mgr01 m2 = Mgr01.getInstance();
        System.out.println(m1 == m2);
    }
}

第二种写法

第二种写法与第一种写法几乎没有区别，只是使用了静态代码块进行对象的初始化
但是该写法仍然没有解决类加载时初始化的问题

/**
 * 与Mgr01意思相同
 */
public class Mgr02 {
    //这里加上final没有初始化，但是在下面必须加static静态代码块进行初始化
    private static final Mgr02 Instance;

    static{
        Instance = new Mgr02();
    }

    private Mgr02(){}

    public static Mgr02 getInstance(){return Instance;}

    public static void main(String[] args) {
        Mgr02 m1 = Mgr02.getInstance();
        Mgr02 m2 = Mgr02.getInstance();
        System.out.println(m1 == m2);
    }
}

第三种写法

懒汉式：

　　优点：在需要的时候进行对象初始化，解决了以上两种写法的缺点

　　缺点：带来了线程不安全的问题

在进行判断是否存在Instance实例时，我们假设有现后两个线程，一号线程刚判断完发现没有实例，正准备进行new时，二号线程突然进入，判断结果同样为没有Instance实例，这时就会有两个线程先后执行new操作

/**
 * 懒汉式
 * 达到了按需初始化的目的，但是带来了线程不安全的问题
 */
public class Mgr03 {
    //这里不能加final，因为加上final就必须进行初始化new对象
    private static Mgr03 Instance;

    private Mgr03(){}

    public static Mgr03 getInstance(){
        if (Instance == null){
            //多线程同时打入的时候容易在这里产生误差
            Instance = new Mgr03();
        }
        return Instance;
    }

    public static void main(String[] args) {
        Mgr03 m1 = Mgr03.getInstance();
        Mgr03 m2 = Mgr03.getInstance();
        System.out.println(m1 == m2);
    }
}

第四种写法

在getInstance方法上加锁来保证线程安全，但是如果每个线程在执行getInstance时都进行加锁操作，那么就会降低程序执行效率

/**
 * 增加了线程的安全性，但是降低了程序执行效率
 */
public class Mgr04 {
    private static Mgr04 Instance;

    private Mgr04(){}

    public static synchronized Mgr04 getInstance(){
        if (Instance == null){
            Instance = new Mgr04();
        }
        return Instance;
    }
    public static void main(String[] args) {
        Mgr04 m1 = Mgr04.getInstance();
        Mgr04 m2 = Mgr04.getInstance();
        System.out.println(m1 == m2);
    }
}

第五种写法

试图通过同步代码块的方式在保证线程安全的前提下提高效率

同步代码块只加在需要new实例的时候

这样虽然提高了程序执行效率，但是显然是不能保证线程安全的

假设有两个线程：线程一在if条件判断结束后发现没有实例，正在往下执行但是还没有进入同步代码块时，线程二进入也同样判断没有实例，线程二比线程一提前拿到锁new出来实例后释放锁，等到线程二释放锁之后线程一又执行方法new出来实例。这样就导致了线程的不安全性

public class Mgr05 {
    private static Mgr05 Instance;

    private Mgr05(){}

    public static Mgr05 getInstance(){
        if (Instance == null){
            /**
             * 试图通过同步代码块的方式提高效率
             * 但是这里又很容易造成线程不安全问题
             */
            synchronized (Mgr05.class){
                Instance = new Mgr05();
            }
        }
        return Instance;
    }
    public static void main(String[] args) {
        Mgr05 m1 = Mgr05.getInstance();
        Mgr05 m2 = Mgr05.getInstance();
        System.out.println(m1 == m2);
    }
}

第六种写法(比较完美的写法之一)

双重if判断来保证只有一个实例对象

这样即不会出现线程不安全问题，又保证了不会随着类加载而创建出来实例

public class Mgr06 {
    //加volatile主要是为了防止指令重排
    private static volatile Mgr06 Instance;

    private Mgr06(){}

    public static Mgr06 getInstance(){
        //第一个进入方法的线程进行Instance实例是否存在的判断
        if (Instance == null){
            //同步代码块进行加锁
            synchronized (Mgr06.class){
                //双重锁机制进行判断Instance对象是否被实例
                if (Instance == null){
                    Instance = new Mgr06();
                }
            }
        }
        return Instance;
    }
    public static void main(String[] args) {
        Mgr06 m1 = Mgr06.getInstance();
        Mgr06 m2 = Mgr06.getInstance();
        System.out.println(m1 == m2);
    }
}

第七种写法(比较完美的写法之一)

使用静态内部类来保证只有一个实例

静态内部类在加载类的时候是不会被加载的，而getInstance方法在执行返回Instance实例调用静态内部类时，静态内部类才会被加载，保证了在使用时才会创建实例

JVM只会加载一次类，同样也只会加载一次静态内部类，这样就保证了线程安全，只会产生一个实例对象

/**
 * 使用静态内部类保证单例，同时也保证线程安全
 * 线程安全是用过JVM机制来保证的
 * JVM只会加载一次Mgr07这个类，只会加载一次Mgr07Holder这个内部类
 *      这也就保证了只会生成一个Instance实例
 */
public class Mgr07 {
    private Mgr07(){}

    /**
     * 使用静态内部类进行实现
     * 当Mgr07这个类被加载时，里面的内部类是不会被加载的，保证了类加载时不完成实例化
     * 当调用getInstance方法时内部类才会加载，也保证了只有一个实例
     */
    private static class Mgr07Holder{
        private static final Mgr07 Instance = new Mgr07();
    }

    public static Mgr07 getInstance(){
        return Mgr07Holder.Instance;
    }

    public static void main(String[] args) {
        Mgr07 m1 = Mgr07.getInstance();
        Mgr07 m2 = Mgr07.getInstance();
        System.out.println(m1 == m2);
    }
}

第八种写法(最完美的写法)

枚举单例模式，枚举类中没有构造方法，保证了仅仅实例化一个对象

只有在调用Instance实例的时候才会创建实例，保证了在使用时才会创建实例

/**
 * 枚举单例模式：通过枚举进行单例模式的实例创建
 * 原因：枚举类中没有构造方法
 * 不仅可以解决线程同步，还可以防止反序列化
 */
public enum Mgr08 {

    Instance;

    public static void main(String[] args) {
        Mgr08 m1 = Mgr08.Instance;
        Mgr08 m2 = Mgr08.Instance;
        System.out.println(m1 == m2);
    }
}