单例模式详解-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_27552845/article/details/108418324

16.单例模式与多线程

所谓单例，最重要的一个思想就是构造器私有，这样别人就没办法去new这个对象了。

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
注意：
1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。

主要解决：一个全局使用的类频繁地创建与销毁。

单例的实现思路

静态化实例对象
私有化构造方法，禁止通过构造方法创建实例
提供一个公共的静态方法，用来返回唯一实例

单例的好处

只有一个对象，内存开支少、性能好
避免对资源的多重占用
在系统设置全局访问点，优化和共享资源访问

16.1饿汉式单例(不推荐)

饿汉式单例一上来就new对象会造成资源的浪费，而且多线程会破坏单例原则。

package com.single;

/**
 * Created by yj on 2020/8/30 20:33
 */
//1.饿汉式单例,饿汉式单例一上来就new对象会造成资源的浪费
public class Hungry01 {
    //构造器私有
    private Hungry01(){
    }
    //new一个对象
    private final static Hungry01 HUNGRY = new Hungry01();
    //创建对象返回方法
    public static Hungry01 getInstance(){
        return HUNGRY;
    }

}

16.2懒汉式单例(多线程不推荐)

懒汉式单例,它是在要使用对象的时候才加载。

饿汉式单例用一个if去判断当前实例对象是否生成，未生成的话就new一个，已经生成了就直接返回这个对象实例
在多线程下是不安全的，要求的是任何线程其拿到的对象实例应该是一个对象实例，因为单例就是只返回一个对象实例，也就是只有第一个线程能用以下构造器，其他的都不能使用构造器，直接拿到对象实例返回即可。

package com.single;

import java.util.TreeMap;

/**
 * Created by yj on 2020/8/30 20:47
 */
//2.懒汉式单例,它是在要使用对象的时候才加载
public class LazyMan02 {
    private LazyMan02(){
        System.out.println(Thread.currentThread().getName()+"====>ok");
    }
    private static LazyMan02 lazyMan;
    //用一个if去判断当前实例对象是否生成，未生成的话就new一个，已经生成了就直接返回这个对象实例
    //但是这个在多线程下是不安全的，要求的是任何线程其拿到的对象实例应该是一个对象实例，因为单例就是只返回一个对象实例
    public static LazyMan02 getInstance(){
        if(lazyMan==null){
            lazyMan = new LazyMan02();
        }
        return lazyMan;
    }
    //单线程下单例,没问题，多线程单例出现问题
    public static void main(String[] args) throws Exception {
        for(int i=0;i<10;i++){
            new Thread(()->{
                LazyMan02.getInstance();
            }).start();
        }
    }

}

16.3dcl双重校验锁懒汉式(多线程推荐,存在隐患)

可以看到这样构造器就初始化了一次，但是有10个线程操作了这个单例。

第一个if是判断是否当前这个实例对象已经创建。
第二个if原因：第一个线程进入第一个if,拿到锁进入第二个if并创建实例对象，此时仍然未创建完对象，而其他线程在锁这儿阻塞，如果没有第二个if，只有第一个if的话其他线程已经进入第一个if后阻塞了，这样就会创建一个新的实例对象，违背单例原则，但是如果有第二个if,此时第一个线程实例对象已经创建了，后面的线程判断出来实例对象不为空了，就会退出去返回第一个线程创建的实例。
volatile原因主要是因为它能够禁止指令重排，因为new一个对象不是一个原子性操作，它分为分配内存，初始化对象，对象指向空间，如果第一个线程创建对象实例时候指令重排时候其顺序乱了（先对象指向空间，还未完成对象初始化），那么此时第二个线程在第一个if处判断出实例对象已经有了，它会直接返回实例对象，而此时这个第一个线程只是将对象指向了空间，还未完成对象的构造，就会出错。

package com.single;

/**
 * Created by yj on 2020/8/30 20:47
 */
//3.dcl双重校验锁形式
public class DCLazyMan03 {
    private DCLazyMan03(){
        System.out.println(Thread.currentThread().getName()+"构造器+====>ok");
    }

    private volatile static DCLazyMan03 lazyMan;//加这个原因是为了防止指令重排

    public static DCLazyMan03 getInstance(){
        if(lazyMan==null){
            synchronized (DCLazyMan03.class){
                //为什么这儿要再校验一次是否是null，因为第一个线程在进入第一个if以后拿到锁了，
                //由于此时lazyMan仍然是空的，那么其他线程能进入第一个if，这时候其他线程都在阻塞，当第一个线程创建完实例以后
                //如果没有第二个if，其他线程会进入里面，再创建一个实例，这就违背了单例的原则了，所以再加一个判断，第一个
                //线程在进入这个if以后，在它刚创建实例对象后，释放了锁。其他正在阻塞的线程也进入了第一个if，拿到锁后，发现此时
                //这个已经不为null了，所以此时就不会进入，直接返回已经创建好的实例，维护了单例模式。
                if(lazyMan==null){
                    /**其实下面这步在底层编译为class文件的时候是三个步骤
                    * 1.在堆中分配对象内存
                     *2.执行构造方法，初始化对象
                     *3.把对象指向这个空间
                     *编译器编译代码的时候可能会先指向1，2，3，但是也有可能指向1，3，2
                     *如果此时线程A编译后执行的是1，3，2，由于此时对象已经指向了这个空间，那么线程B进来的时候就判断不为null，返回
                     *直接返回实例，此时就会出现一个问题，就是当前的对象其实没有完成构造，这时候返回就有问题。
                     * 所以上面要加volatile
                     */
                    lazyMan = new DCLazyMan03();//这个并不是一个原子性操作，它会分成三个步骤执行，这时候编译的时候会出现指令重排现象
                }
            }

        }
        return lazyMan;
    }
    public static void main(String[] args) throws Exception {
        for(int i=0;i<10;i++){
            new Thread(()->{
                DCLazyMan03.getInstance();
                System.out.println(Thread.currentThread().getName()+"线程+====>ok");
            }).start();
        }
    }

}

16.4静态内部类(不推荐)

package com.single;

/**
 * Created by yj on 2020/9/4 23:14
 */
//4.静态内部类
public class Holder04 {
    private Holder04(){

    }

    public static Holder04 getInstance(){
        return InnerClass.HOLDER_04;
    }

    public static class InnerClass{
        private static final Holder04 HOLDER_04 = new Holder04();
    }
}

16.5单例模式的安全性问题(解决懒汉式隐患)

单例模式可以被反射破坏原则,它可以通过反射去创建一个新的实例,解决方法就是设置一个加密的变量放在构造器处,默认为false,如果这个构造器被调用过了就为ture,以此来判断这个构造器是否可用,这样就保证了这个构造器只能被用一次,保证了单例的原则.

这样做不论即使是两次使用反射去创建实例,他也能判断出来,抛出异常从而解决问题.

但是这样做,如果被外部猜出了这个secrect标量,那么也是会产生问题的,可以通过反射去修改这个标量的值.

package com.single;

import java.lang.reflect.Constructor;

/**
 * Created by yj on 2020/8/30 20:47
 */
//5.解决反射破坏单例情况
public class ReflectDCLazyMan05 {

    private static boolean secrect = false;
    private ReflectDCLazyMan05(){
        synchronized (ReflectDCLazyMan05.class){
            if(secrect==false){
                secrect = true;
            }
            else{
                throw new RuntimeException("不要用反射来破坏单例");
            }
        }

    }

    private volatile static ReflectDCLazyMan05 lazyMan;//加这个原因是为了防止指令重排

    public static ReflectDCLazyMan05 getInstance(){
        if(lazyMan==null){
            synchronized (ReflectDCLazyMan05.class){
                if(lazyMan==null){
                    lazyMan = new ReflectDCLazyMan05();//这个并不是一个原子性操作，它会分成三个步骤执行，这时候编译的时候会出现指令重排现象
                }
            }

        }
        return lazyMan;
    }
    public static void main(String[] args) throws Exception {
        /**
         * 下面会发现反射能创出一个不一样的实例对象
        * */
        ReflectDCLazyMan05 instance = ReflectDCLazyMan05.getInstance();
        Constructor<ReflectDCLazyMan05> declaredConstructor = ReflectDCLazyMan05.class.getDeclaredConstructor(null);//通过反射
        declaredConstructor.setAccessible(true);//它可以无视私有构造器,破除私有权限
        ReflectDCLazyMan05 instrance2 = declaredConstructor.newInstance();
        System.out.println(instance);
        System.out.println(instrance2);

    }

}

16.6单例模式使用枚举类(推荐):

Constructor<EnumSingle06> declaredConstructor = EnumSingle06.class.getDeclaredConstructor(String.class,int.class);
declaredConstructor.setAccessible(true);
EnumSingle06 instance2 = declaredConstructor.newInstance();

可以看下这个反射创建实例的源码,显示对于枚举类型,会抛出异常不能通过反射创建枚举类型:

为什么枚举类型用作单例很好

1.枚举类型是线程安全的
2.枚举类型只会装载一次
3.反射部分创建实例的部分源码已经写了不能用反射区创建枚举

package com.single;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**
 * Created by yj on 2020/9/5 11:17
 */
//enum类型是一个类
//枚举类型是所用单例实现中唯一一种不会被破坏的单例实现模式。
/**1.枚举类型是线程安全的
 * 2.枚举类型只会装载一次
 * * */
public enum EnumSingle06 {
    INSTANCE;//创建一个枚举对象，该对象天生为单例

    public EnumSingle06 getInstance(){
        return INSTANCE;
    }
}

class Test{

    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        EnumSingle06 instance1 = EnumSingle06.INSTANCE;
        Constructor<EnumSingle06> declaredConstructor = EnumSingle06.class.getDeclaredConstructor(String.class,int.class);
        declaredConstructor.setAccessible(true);
        EnumSingle06 instance2 = declaredConstructor.newInstance();

        // NoSuchMethodException: com.kuang.single.EnumSingle.<init>()
        System.out.println(instance1);
        System.out.println(instance2);

    }

}