互联网架构-精讲设计模式-010：深入理解单例模式

最新推荐文章于 2022-11-10 23:59:04 发布

竞风之翼

最新推荐文章于 2022-11-10 23:59:04 发布

阅读量781

点赞数 1

分类专栏：蚂蚁课堂第5期视频笔记文章标签： java 设计模式

本文链接：https://blog.csdn.net/u012425860/article/details/109848185

版权

蚂蚁课堂第5期视频笔记专栏收录该内容

59 篇文章 24 订阅

订阅专栏

010：深入理解单例模式

1 饿汉式模式

课程内容:
1、什么是单例模式？单例的应用场景
2、完全解密单例的七种写法
3、如何去破解一个单例，创建多次
4、如何防止反射、序列化破解单例

什么是单例模式
单例模式确保一个类只有一个实例，并提供一个全局访问点，实现单例模式的方法是私有化构造函数，通过getInstance()方法实例化对象，并返回这个实例。

单例模式优缺点
优点：
1、单例类只有一个实例
2、共享资源，全局使用
3、节省创建时间，提高性能
缺点：可能存在线程不安全的问题

单例的七种写法
分别是「饿汉」、「懒汉(非线程安全)」、「懒汉(线程安全)」、「双重校验锁」、「静态内部类」、「枚举」和「容器类管理」

饿汉式

public class SingletonV1 {

    /**
     * 饿汉式 优点：先天线程安全 当类被加载的时候就会创建该对象
     * 缺点：如果项目中使用过多饿汉式，项目在启动的时候非常慢，存放在方法区占用内存比较大
     * 如果用户不使用该对象的时候，也会被提前创建，浪费资源
     */
    private static SingletonV1 singletonV1 = new SingletonV1();

    private SingletonV1() {
    }

    /**
     * 返回该对象的实例
     *
     * @return
     */
    public static SingletonV1 getInstance() {
        return singletonV1;
    }
}

public class SingletonV1Test {
    public static void main(String[] args) {
        SingletonV1 instance1 = SingletonV1.getInstance();
        SingletonV1 instance2 = SingletonV1.getInstance();
        System.out.println(instance1 == instance2); // true
    }
}

优点：先天性线程是安全的，当类初始化的时候就会创建该对象
缺点：如果饿汉式使用过多，可能会影响项目启动的效率问题。

2 懒汉式模式(线程不安全)

懒汉式（线程不安全）

public class SingletonV2 {

    // 懒汉式 当真正需要使用该对象的时候才会被初始化
    private static SingletonV2 singletonV2;

    private SingletonV2(){}

    /**
     * 可能存在线程安全问题，在多线程的情况下，可能会被初始化多次
     * @return
     */
    public static SingletonV2 getInstance(){
        // 当第一次singletonV2等于null的情况下才会被初始化，第二次直接返回对象
        if(singletonV2 == null){
            singletonV2 = new SingletonV2();
        }
        return singletonV2;
    }
}

public class SingletonV2Test {
    public static void main(String[] args) {
        SingletonV2 instance1 = SingletonV2.getInstance();
        SingletonV2 instance2 = SingletonV2.getInstance();
        System.out.println(instance1 == instance2); // true
    }
}

懒汉式模拟高并发场景线程不安全问题

public class SingletonV2 {

    // 懒汉式 当真正需要使用该对象的时候才会被初始化
    private static SingletonV2 singletonV2;

    private SingletonV2(){}

    /**
     * 可能存在线程安全问题，在多线程的情况下，可能会被初始化多次
     * @return
     */
    public static SingletonV2 getInstance(){
        // 当第一次singletonV2等于null的情况下才会被初始化，第二次直接返回对象
        if(singletonV2 == null){
            try{
                Thread.sleep(3000);
            }catch(Exception e){
                e.printStackTrace();
            }
            singletonV2 = new SingletonV2();
        }
        return singletonV2;
    }
}

public class SingletonV2Test {
    public static void main(String[] args) {
        // 模拟高并发情况下 懒汉式线程安全问题
        for (int i = 0; i < 300; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    SingletonV2 singletonV2 = SingletonV2.getInstance();
                    System.out.println(Thread.currentThread().getName() + "," + singletonV2);
                }
            }).start();
        }
    }
}

在这里插入图片描述
在getInstance()方法上加上synchronized可以解决线程安全问题，但是运行如同单线程，效率较低。

3 双重检验锁原理

懒汉式解决线程安全问题为什么效率比较低？
线程安全问题，当多个线程共享同一个数据做写的操作，可能会存在线程安全问题，读不存在线程安全问题。
懒汉式解决线程安全（加上synchronized）读和写都加上了锁，应该是第一次创建对象的时候才会加锁，之后获取该对象的时候不需要加锁。

双重检验锁目的是什么？
解决懒汉式（线程安全）获取对象效率问题。

双重检验锁

public class SingletonV3 {

    /**
     * volatile 防止重排序 java内存模型 保证可见性
     */
    private volatile static SingletonV3 singletonV3;
    // 双重检验锁 解决懒汉式读和写都加锁
    private SingletonV3(){}

    public static SingletonV3 getInstance() {

        // 当多个线程同时可能在new对象的时候，才会加锁，保证线程安全问题
        if (singletonV3 == null) {
            synchronized (SingletonV3.class) {
                if (singletonV3 == null) { // 当前线程已经获取到锁了，再判断该对象是否已经初始化，没有初始化的话开始创建
                    singletonV3 = new SingletonV3();
                }
            }
        }
        return singletonV3;
    }

}

注：如果没有第二个if (singletonV3 == null)，假设第一个if (singletonV3 == null)同时有10个线程进入，synchronized只是保证一个线程获取到锁，第一个获取锁的线程最先创建对象，后面9个线程随后获取锁同样也会创建对象，导致一共创建10个对象。而如果有第二个if，那只有第一个获取锁的线程创建对象成功，后面线程不创建，保证单例。

测试效果：

public class SingletonV3 {

    /**
     * volatile 防止重排序 java内存模型 保证可见性
     */
    private volatile static SingletonV3 singletonV3;
    // 双重检验锁 解决懒汉式读和写都加锁
    private SingletonV3(){}

    public static SingletonV3 getInstance() {

        // 当多个线程同时可能在new对象的时候，才会加锁，保证线程安全问题
        if (singletonV3 == null) {
            try{
                Thread.sleep(3000);
            }catch(Exception e){
                e.printStackTrace();
            }
            synchronized (SingletonV3.class) {
                if (singletonV3 == null) { // 当前线程已经获取到锁了，再判断该对象是否已经初始化，没有初始化的话开始创建
                    singletonV3 = new SingletonV3();
                }
            }
        }
        return singletonV3;
    }

}

public class SingletonV3Test {
    public static void main(String[] args) {
        // 模拟高并发情况下 懒汉式线程安全问题
        for (int i = 0; i < 300; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    SingletonV3 singletonV3 = SingletonV3.getInstance();
                    System.out.println(Thread.currentThread().getName() + "," + singletonV2);
                }
            }).start();
        }
    }
}

在这里插入图片描述第一次执行(创建对象)慢，因为走了sleep方法，后面执行都快。

4 静态内部类方式

如何解决写和读都不加锁，还能保证唯一性，线程安全问题？
静态内部类

public class SingletonV4 {

    private SingletonV4() {
        System.out.println("构造函数被初始化...");
    }

    public static SingletonV4 getInstance() {
        return SingletonV4Utils.singletonV4;
    }

    // 在类里面嵌套的
    private static class SingletonV4Utils {
        private static final SingletonV4 singletonV4 = new SingletonV4();
    }

    /**
     * 内部类在调用的时候才会初始化singletonV4
     * static 静态 保证唯一
     * @param args
     */
    // 静态内部类特征：继承懒汉式和饿汉式优点、同时解决双重检验锁第一次加载慢的问题 读和写都不需要同步效率非常高...
    public static void main(String[] args) {
        System.out.println("项目启动成功...");
        SingletonV4 instance1 = SingletonV4.getInstance();
        SingletonV4 instance2 = SingletonV4.getInstance();
        System.out.println(instance1 == instance2); // true
    }
}

懒加载：内部类在调用的时候才会创建对象
保证线程安全问题：静态对象static保证唯一性

在这里插入图片描述

5 使用反射技术破解单例

单例基本原则：保证在单个jvm中不重复创建
虽然单例通过私有构造函数，可以实现防止程序员初始化对象，但是还可以通过反射和序列化技术破解单例。

使用反射技术破解单例

public class SingletonV3Test2 {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        SingletonV3 instance1 = SingletonV3.getInstance();
        // 如何去破解单例 使用java反射技术、序列化技术
        Constructor<SingletonV3> declaredConstructor = SingletonV3.class.getDeclaredConstructor();
        declaredConstructor.setAccessible(true);
        // 使用java的反射技术创建
        SingletonV3 instance2 = declaredConstructor.newInstance();
        System.out.println(instance1 == instance2); //false
    }
}

如何防止被反射破解----私有化构造函数

…
    private SingletonV3() throws Exception {
        if(singletonV3 !=null){
            throw new Exception("对象已经被初始化...");
        }
        System.out.println("SingletonV3被初始化...");
    }
…

在这里插入图片描述

6 使用序列化破解单例

反序列化创建对象破解单例

public class SingletonV5 implements Serializable {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // java的序列化技术
        /**
         * 对象从内存写入到硬盘中 序列化
         * 从硬盘中读取到内存 反序列化
         */
        SingletonV5 instance1 = SingletonV5.getInstance();
        FileOutputStream fos = new FileOutputStream("D:\\code\\Singleton.obj");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(instance1);
        oos.flush();
        oos.close();

        // 反序列化
        FileInputStream fis = new FileInputStream("D:\\code\\Singleton.obj");
        ObjectInputStream ois = new ObjectInputStream(fis);
        SingletonV5 instance2 = (SingletonV5) ois.readObject();
        System.out.println(instance1 == instance2); //false
    }

    private static SingletonV5 singletonV5 = new SingletonV5();

    private SingletonV5() {}

    public static SingletonV5 getInstance() {
        return singletonV5;
    }

/*    //返回序列化获取对象 ，保证为单例
    public Object readResolve() {
        return singletonV5;
    }*/

}

在这里插入图片描述

7 枚举方式防止破解

枚举方式防止破解

public enum EnumSingleton {
    INSTANCE;

    // 枚举能够绝对有效的防止实例化多次,和防止反射和序列化破解
    public void add() {
        System.out.println("add方法...");
    }
}

public class EnumSingletonTest {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        EnumSingleton instance1 = EnumSingleton.INSTANCE;
        EnumSingleton instance2 = EnumSingleton.INSTANCE;
        System.out.println(instance1 == instance2);
        instance1.add();

        Constructor<EnumSingleton> declaredConstructor = EnumSingleton.class.getDeclaredConstructor();
        declaredConstructor.setAccessible(true);
        EnumSingleton instance3 = declaredConstructor.newInstance();
        System.out.println(instance3 == instance1);
    }
}

在这里插入图片描述
枚举类没有无参构造函数，不能通过反射方式创建对象。

竞风之翼

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
4
评论
互联网架构-精讲设计模式-010：深入理解单例模式

010：深入理解单例模式1 饿汉式模式2 懒汉式模式(线程不安全)3 双重检验锁原理4 静态内部类方式5 使用反射技术破解单例6 使用序列化破解单例7 枚举方式防止破解1 饿汉式模式课程内容:1、什么是单例模式？单例的应用场景2、完全解密单例的七种写法3、如何去破解一个单例，创建多次4、如何防止反射、序列化破解单例什么是单例模式单例模式确保一个类只有一个实例，并提供一个全局访问点，实现单例模式的方法是私有化构造函数，通过getInstance()方法实例化对象，并返回这个实例。单例模式优缺
复制链接

扫一扫