单例模式学习

单例模式

整体

考察点	饿汉式	懒汉式(线程安全)	懒汉式(线程不安全)	双重检验锁	内部类	枚举
是否Lazy初始化	否	是	是	是	是	否
是否多线程安全	是	是	否	是	是	是
实现难度	易	易	易	较复杂	一般	易
描述	这种方式比较常用，但容易产生垃圾	这种方式具备很好的lazy loading，能够在多线程下很好的工作，但是效率很低	这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，所以严格意义上它并不算单例模式。 这种方式 lazy loading 很明显，不要求线程安全，在多线程不能正常工作。	采用双锁机制，安全且在多线程下保持高性能	这种方式能达到双检锁方式一样的功效，但实现更简单。对静态域使用延迟初始化，应使用这种方式而不是双检锁方式。这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用。 这种方式同样利用了 classloader 机制来保证初始化 instance 时只有一个线程，它跟第 3 种方式不同的是：第 3 种方式只要 Singleton 类被装载了，那么 instance 就会被实例化（没有达到 lazy loading 效果），而这种方式是 Singleton 类被装载了，instance 不一定被初始化。因为 SingletonHolder 类没有被主动使用，只有通过显式调用 getInstance 方法时，才会显式装载 SingletonHolder 类，从而实例化 instance。想象一下，如果实例化 instance 很消耗资源，所以想让它延迟加载，另外一方面，又不希望在 Singleton 类加载时就实例化，因为不能确保 Singleton 类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化 instance 显然是不合适的。这个时候，这种方式相比第 3 种方式就显得很合理。	这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。 这种方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。不过，由于 JDK1.5 之后才加入 enum 特性，用这种方式写不免让人感觉生疏，在实际工作中，也很少用。 不能通过 reflection attack 来调用私有构造方法。
优点	没有加锁，执行效率高	第一次调用才进行初始化，避免内存浪费
缺点	类加载时就进行初始化，浪费内存	必须加锁才能保证单例，但是加锁会影响执行效率

饿汉式

这种方式比较常用，但容易产生垃圾

package com.markus.basic.设计模式.单例模式;
/**
 * Author:markusZhang
 * Date:Create in 2020/8/24 15:59
 * todo: 饿汉式
 */
public class SingleTon2 {
    private static SingleTon2 instance = new SingleTon2();
    private SingleTon2(){}
    public static SingleTon2 getInstance(){
        return instance;
    }
}

懒汉式

线程不安全

这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，所以严格意义上它并不算单例模式。这种方式 lazy loading 很明显，不要求线程安全，在多线程不能正常工作。

线程安全

这种方式具备很好的lazy loading，能够在多线程下很好的工作，但是效率很低

代码

package com.markus.basic.设计模式.单例模式;

/**
 * Author:markusZhang
 * Date:Create in 2020/8/24 15:51
 * todo: 懒汉式
 */
public class SingleTon1 {
    private static SingleTon1 instance;

    /**
     * 将构造器设为私有
     */
    private SingleTon1(){}

    /**
     * 线程不安全
     */
    public static SingleTon1 getInstance(){
        if (instance == null){
            instance = new SingleTon1();
        }
        return instance;
    }

    /**
     * 线程安全
     */
    public static synchronized SingleTon1 getInstanceWithLock(){
        if (instance == null){
            instance = new SingleTon1();
        }
        return instance;
    }

}

双重检验锁

采用双锁机制，安全且在多线程下保持高性能

package com.markus.basic.设计模式.单例模式;

import java.io.Serializable;

/**
 * Author:markusZhang
 * Date:Create in 2020/8/24 16:10
 * todo: 双重检验锁
 */
public class SingleTon3 implements Serializable {
    private static volatile SingleTon3 instance;
    private SingleTon3(){}
    public static SingleTon3 getInstance(){
        //第一步判断就是让实例不为空时，快速返回，避免了加锁浪费时间
        if (instance == null){
            synchronized (SingleTon3.class){
                //第二重检验，保证线程拿到锁之后确实 实例是空的
                if (instance == null){
                    instance = new SingleTon3();
                }
            }
        }
        return instance;
    }
    //这个方法的作用就是防止序列化破坏单例
    public Object readResolve(){
        return instance;
    }
}

内部类

这种方式能达到双检锁方式一样的功效，但实现更简单。对静态域使用延迟初始化，应使用这种方式而不是双检锁方式。这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用。这种方式同样利用了 classloader 机制来保证初始化 instance 时只有一个线程，它跟第 3 种方式不同的是：第 3 种方式只要 Singleton 类被装载了，那么 instance 就会被实例化（没有达到 lazy loading 效果），而这种方式是 Singleton 类被装载了，instance 不一定被初始化。因为 SingletonHolder 类没有被主动使用，只有通过显式调用 getInstance 方法时，才会显式装载 SingletonHolder 类，从而实例化 instance。想象一下，如果实例化 instance 很消耗资源，所以想让它延迟加载，另外一方面，又不希望在 Singleton 类加载时就实例化，因为不能确保 Singleton 类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化 instance 显然是不合适的。这个时候，这种方式相比第 3 种方式就显得很合理。

package com.markus.basic.设计模式.单例模式;

/**
 * Author:markusZhang
 * Date:Create in 2020/8/24 16:22
 * todo: 静态内部类
 */
public class SingleTon4 {
    private static class CreateSingleTon{
        private static SingleTon4 instance;
        public  static SingleTon4 getInstance(){
            if (instance == null){
                instance = new SingleTon4();
            }
            return instance;
        }
    }
    private SingleTon4(){}
    public static SingleTon4 getInstance(){
        return CreateSingleTon.getInstance();
    }
}

枚举

这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。这种方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。不过，由于 JDK1.5 之后才加入 enum 特性，用这种方式写不免让人感觉生疏，在实际工作中，也很少用。不能通过 reflection attack 来调用私有构造方法。

package com.markus.basic.设计模式.单例模式;

/**
 * Author:markusZhang
 * Date:Create in 2020/8/24 16:27
 * todo: 枚举
 */
public enum SingleTon5 {
    SINGLE_TON_5;
    public void getInstance(){
    }
}