【Java多线程】案例(1)：设计模式

new Random()

已于 2024-04-09 16:47:19 修改

阅读量1.3k

点赞数 34

分类专栏： Java 文章标签： java 设计模式多线程单例模式

于 2024-04-03 19:31:39 首次发布

本文链接：https://blog.csdn.net/sjsjzhx/article/details/137349495

版权

Java 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

一、什么是设计模式？

设计模式是针对软件设计中常见问题的通用解决方案。它们提供了一种被广泛接受的方法来解决特定类型的问题，并且具有经过验证的效果和可重复使用性。设计模式不是代码或类库，而是一种解决问题的思维方式或模式。

设计模式就好比象棋中的“棋谱”，针对对方的一些走法，黑方应招的时候有一些固定的套路，按照套路走局势就不会吃亏。想要成为一名象棋高手，背棋谱其实是必然的。因此，设计模式也是开发中的一种重要的解决问题的方式。

二、单例模式

单例模式是校招中 最常考的设计模式 之⼀。

单例模式能保证某个类在程序中只存在唯一一份实例，而不会创建出多个实例。

单例模式具体的实现方式有很多，最常见的是" 饿汉"和" 懒汉"两种。

1. 饿汉模式

饿汉式单例（Eager Initialization）：在类加载时就创建实例。

// 单例模式 - 饿汉模式
// 类加载的同时，直接创建实例。
class Singleton {
    // 在类加载时就创建实例
    private static Singleton instance = new Singleton();

    // 对外提供获取实例的静态方法
    public static Singleton getInstance() {
        return instance;
    }

    // 私有化构造方法，防止外部直接实例化
    private Singleton() {
    }
}

public class Demo1 {
    public static void main(String[] args) {
        // 获取单例对象
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        
        // 判断两个实例是否相同
        System.out.println(s1 == s2);  // 输出 true，说明两个引用指向同一个实例

        // 以下代码会报错，因为构造方法是私有的，无法在外部直接实例化
        // Singleton s = new Singleton();
    }
}

上述代码类加载就会创建实例的原因：

在Java中，类加载时机是在首次使用该类时，Java虚拟机会负责对类进行加载、连接和初始化。在加载阶段，虚拟机会加载类的字节码并创建Class对象，而在初始化阶段，虚拟机会执行类的初始化过程，其中包括对静态变量的初始化。因此，在首次使用该类时，类会被加载并且静态变量会被初始化，从而创建单例实例。

通过对构造方法的私有化，使得上述代码只有一个实例。

由于单例对象在类加载时就被创建，因此不存在线程安全问题。但如果实例很大且长时间未使用，会造成资源浪费。

2. 懒汉模式

懒汉式单例（Lazy Initialization）：在第一次调用时创建实例。

public class Singleton {
    private static Singleton instance = null;
    
    private Singleton() {
        // 私有化构造方法
    }
    
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

注意：此示例不是线程安全的【Java多线程（3）】线程安全问题和解决方案

线程安全问题发生在首次创建实例时，如果多个线程中同时调用getInstance方法，由于线程的抢占式执行，就可能导致创建出多个实例。

如果实例创建好了，后面在多线程环境调用getInstance就不再有线程安全问题了，因为不会再new实例了。

因此，加上synchronized 就能够解决这里的创建多个实例的问题。

懒汉模式-第一次改进

public class SingletonLazy {
    private static volatile SingletonLazy instance = null;

    public static SingletonLazy getInstance() {
        synchronized (SingletonLazy.class) {
            if (instance == null) {
                instance = new SingletonLazy();
            }
        }
        return instance;
    }

    private SingletonLazy() {
    }
}

这样操作后，就能保证只有第一个调用getInstance方法的线程会创建实例，其余线程即使抢到CPU执行权，也会被阻塞。后续条件判断的时候也就不会再new了。

但是，饿汉模式只有在最开始调用getInstance会存在线程安全问题，后续再调用是没有线程安全问题的。而上述代码针对后续调用，明明没有线程安全问题，却还是要加锁（可能导致其他线程阻塞），这使得代码的性能大大降低了。

因此，对于这个问题，还要进行一些改进，就是只在对象还未实例化的时候才对实例化对象的这段代码进行加锁。

懒汉模式-第二次改进

class SingletonLazy {
    private static SingletonLazy instance = null;

    public static SingletonLazy getInstance() {
        if (instance == null) {
            synchronized (SingletonLazy.class) {
                if (instance == null) {
                    instance = new SingletonLazy();
                }
            }
        }
        return instance;
    }

    private SingletonLazy() {
    }
}

使用双重if判定，降低锁竞争的频率。

在 getInstance() 方法中首先检查 instance 是否为 null，如果是 null，表示尚未创建实例，需要进行实例化操作。
由于该方法可能被多个线程同时调用，因此需要使用双重检查锁定来确保只有一个线程创建实例。
在第一次检查 instance 为 null 后，进入同步块，并再次检查 instance 是否为 null，以防止多个线程同时进入同步块后重复创建实例。
如果 instance 仍然为 null，则在同步块内部创建新的 SingletonLazy 实例，并将其赋值给 instance。

这样的做法，即使在对象还未实例化的时候，有多个线程进入第一个if判断了，里面的锁仍会保证只有一个线程会去实例化，并且在后续线程再调用getInstance方法的时候，外层的if判断就把它挡住了，就不会再上锁了。

但是，写出双重if判定的代码的时候，强大的IDEA就已经给出了一个警告：双重检查锁定

既然IDEA都给警告了，意味着这里可能还会问题存在！

懒汉模式-第三次改进

IDEA给我们的处理方式是：给instance加上volatile关键字。

一方面，这里就又涉及到了内存可见性问题：在第一次创建实例中，被阻塞的线程有可能没有感知到instance的引用已经改变了，导致的内存可见性问题。

另一方面，就是我们在【Java多线程（3）】线程安全问题和解决方案这篇博客中还未解决的指令重排序问题，这是我们这里要讨论的重点：

指令重排序，也是编译器的一种优化策略。看一个去超市买菜的例子：

可以看到，优化后的策略节省了不少时间。

而在instance = new SingletonLazy(); 这行代码中，其实会有很多很多的指令，但是大体上可以分成三个步骤：

申请内存空间
调用构造方法（对内存空间进行初始化）
把此时内存空间的地址，赋值给 instance 引用

而在指令重排序的优化下，上述过程不一定是按 123 执行的，也可能是 132 执行(1一定先执行)，这种优化策略，在单线程下都是没有问题的，但 132 在多线程下，可能就会引起bug。假设有t1和t2两个线程，线程间是按照以下顺序执行的：

volatile解决的就是上述两个问题（内存可见性和指令重排序(保证执行顺序是123)）

因此，懒汉模式的最终代码就是在第二次改进的基础上，给instance加上volatile关键字。

//懒汉模式-最终代码
class SingletonLazy {
    private static volatile SingletonLazy instance = null;

    public static SingletonLazy getInstance() {
        if (instance == null) {
            synchronized (SingletonLazy.class) {
                if (instance == null) {
                    instance = new SingletonLazy();
                }
            }
        }
        return instance;
    }

    private SingletonLazy() {
    }
}