JavaEE-经典多线程样例

文章目录

单例模式
- 设计模式初步引入
- 为何存在单例模式
- 饿汉式单例模式
- 饿汉式缺陷以及是否线程安全
- 懒汉式单例模式
- 基础懒汉式缺陷以及是否线程安全
- 懒汉式单例模式的改进
- 完整代码(变量volatile)
阻塞队列
- 生产者消费者模型
- 生产者消费者模型的案例以及优点
- - 请求与响应案例
  - 解耦合

单例模式

设计模式初步引入

啥是设计模式?

设计模式好⽐象棋中的 “棋谱”. 红⽅当头炮, ⿊⽅⻢来跳. 针对红⽅的⼀些⾛法, ⿊⽅应招的时候有⼀些固定的套路. 按照套路来⾛局势就不会吃亏.软件开发中也有很多常⻅的 “问题场景”. 针对这些问题场景, ⼤佬们总结出了⼀些固定的套路. 按照这个套路来实现代码, 也不会吃亏, 不针对某一种语言, 而是针对某种开发场景
设计模式并不是只有23种, 因为之前有些大佬写了一本书叫设计模式,重点讨论了23种, 但事实上存在更多种的设计模式
设计模式与框架的区别就是, 设计模式在开发中是软性要求(不一定遵守), 但是框架是硬性要求(一定要遵守)

简单点一句话总结

设计模式是前人根据一些开发场景给出的一些经验之谈, 所以设计模式并不针对某一种语言

为何存在单例模式

单例模式能保证某个类在程序中只存在唯⼀⼀份实例, ⽽不会创建出多个实例.
这⼀点在很多场景上都需要. 比如 JDBC 中的 DataSource 实例就只需要⼀个,再
比如如果一个类的创建需要加载的数据量非常的庞大(GB级别), 那我们不希望这
个类频繁的创建销毁(开销很大), 我们可能只是希望创建一次就可以了

饿汉式单例模式

顾名思义, 这种方式实现的单例模式十分"饥渴", 不管使用不使用都会提前new一个对象

流程如下

构造方法私有化
定义一个静态的类对象用以返回
提供一个公开的静态接口来获取唯一的对象

测试代码如下

/*** 下面定义一个类来测试饿汉式单例模式*/
class HungrySingleton{// 提供一个静态的变量用来返回private static HungrySingleton hungrySingleton = new HungrySingleton();// 构造方法私有化(在外部不可以构造对象)private HungrySingleton(){}// 提供一个获取实例的静态公开接口public static HungrySingleton getInstance(){return hungrySingleton;}
}public class DesignPatternTest {public static void main(String[] args) {// 对饿汉式单例的测试HungrySingleton instance1 = HungrySingleton.getInstance();HungrySingleton instance2 = HungrySingleton.getInstance();// 测试两者是不是一个对象System.out.println(instance1 == instance2);}
}

测试结果
在这里插入图片描述
很明显, 用这种方式创建的实例都是只有一份的…

饿汉式缺陷以及是否线程安全

首先饿汉式的单例模式缺陷是非常明显的

饿汉式不管我们使用这个对象与否, 都会在类加载的时期(因为是静态对象)构建一个这样的对象, 但我们想要达成的效果是, 在我们不需要这种类的实例的时候, 我们不去进行构造对象的操作(变主动为被动)来减少内存等相关资源的开销

但是饿汉式单例一定是线程安全的

构建对象的时期是类加载的时候, 后期不同线程对于这个实例的操作也仅仅是涉及到读操作, 不涉及修改操作, 所以当然是线程安全的, 不存在线程安全问题, 但是另一种实现的模式就不一定了

懒汉式单例模式

上面说了饿汉式单例模式的缺陷, 我们尝试使用懒汉式单例的方式去解决这个问题, 也就是仅仅在需要的时候进行new对象的操作

最基础的懒汉单例模式

构造的逻辑

构造方法私有化
提供一个静态的对象用来返回(暂时不new对象)
提供一个公开访问的静态接口来返回唯一的对象

代码测试(最基础的版本)

/*** 下面定义一个类来测试懒汉式单例模式*/
class LazySingleton{// 提供一个静态的变量用来返回private static LazySingleton lazySingleton = null;// 构造方法私有化(不可以在外部new对象)private LazySingleton(){}// 提供一个公开的获取实例的接口public static LazySingleton getInstance(){if(lazySingleton == null){lazySingleton = new LazySingleton();}return lazySingleton;}
}public class DesignPatternTest {public static void main(String[] args) {// 对懒汉式单例的测试LazySingleton instance1 = LazySingleton.getInstance();LazySingleton instance2 = LazySingleton.getInstance();// 测试两者是不是一个对象System.out.println(instance1 == instance2);}
}

基础懒汉式缺陷以及是否线程安全

这个就和上面饿汉有较大的区别了, 虽然解决了在需要的时候进行new对象, 上面的基础版本的懒汉式在单线程的环境下肯定是没问题的, 但是在多线程的环境下就不好说了…看下面的分析

如果在多线程的环境下(我们假设有t1, t2)是下图的执行顺序
在这里插入图片描述
很明显这是一种类似串行的执行策略

但是还可能是下图的情况
在这里插入图片描述
t1线程判断完毕之后没有来得及进行new对象, t2线程紧接着进行了一次完整的new对象的过程, 此时t1线程又进行了一次new对象的过程, 很明显, 我们上面的情况进行了两次构造对象的过程, 同时拿到的对象也不一致

我们通过Thread.sleep()的方式进行延迟观察看是否会发生

/*** 下面定义一个类来测试懒汉式单例模式*/
class LazySingleton{// 提供一个静态的变量用来返回private static LazySingleton lazySingleton = null;// 构造方法私有化(不可以在外部new对象)private LazySingleton(){}// 提供一个公开的获取实例的接口public static LazySingleton getInstance() throws InterruptedException {if(lazySingleton == null){Thread.sleep(1000);lazySingleton = new LazySingleton();}return lazySingleton;}
}public class DesignPatternTest {private static LazySingleton instance1 = null;private static LazySingleton instance2 = null;public static void main(String[] args) throws InterruptedException {// 创建两个线程获取实例Thread t1 = new Thread(() -> {try {instance1 = LazySingleton.getInstance();} catch (InterruptedException e) {e.printStackTrace();}});Thread t2 = new Thread(() -> {try {instance2 = LazySingleton.getInstance();} catch (InterruptedException e) {e.printStackTrace();}});// 开启两个线程t1.start();t2.start();// 睡眠等待一下Thread.sleep(2000);System.out.println(instance1 == instance2);}
}

在这里插入图片描述
很明显, 这样的懒汉式的代码是线程不安全的, 那要如何进行改进呢???

懒汉式单例模式的改进

之前我们说了, 要想保证线程是安全的, 有几种解决方式, 这里面我们就采取加锁, 因为其实
判断是不是null和对象应该是一个整体的原子性的操作

改进之后的代码

/*** 下面定义一个类来测试懒汉式单例模式(改进版)*/
class LazySingleton{// 提供一个静态的变量用来返回private static LazySingleton lazySingleton = null;// 构造方法私有化(不可以在外部new对象)private LazySingleton(){}// 提供一个公开的获取实例的接口public static LazySingleton getInstance() {// 我们把if判断和new对象通过加锁打包为一个原子性的操作(这里使用类对象锁)synchronized (LazySingleton.class){if(lazySingleton == null){lazySingleton = new LazySingleton();}}return lazySingleton;}
}public class DesignPatternTest {private static LazySingleton instance1 = null;private static LazySingleton instance2 = null;public static void main(String[] args) {// 在多线程中获取实例Thread t1 = new Thread(() -> {instance1 = LazySingleton.getInstance();});Thread t2 = new Thread(() -> {instance2 = LazySingleton.getInstance();});System.out.println(instance1 == instance2);}
}

这时候肯定是一个线程安全的代码了, 但是思考可不可以进一步改进呢???

当我们已经new个一次对象之后, 如果后续的线程想要获取这个对象, 那就仅仅是一个读操作了, 根本不涉及对对象的修改, 但是我们每次都使用锁这样的机制就会造成阻塞, 也就会导致程序的效率下降, 所以我们对代码进行了下面的修改在外层再加一个if判断

改进的方法如下

// 提供一个公开的获取实例的接口public static LazySingleton getInstance() {// 我们把if判断和new对象通过加锁打包为一个原子性的操作(这里使用类对象锁)if (lazySingleton == null) {synchronized (LazySingleton.class) {if (lazySingleton == null) {lazySingleton = new LazySingleton();}}}return lazySingleton;}

我们的两个if的含义

第一个if: 判断对象是否创建完毕, 如果创建了, 只是一个读操作
第二个if: 判断是不是需要new对象

可能初学多线程的时候, 看上述代码觉得很迷惑, 但其实这是因为之前我们写的程序都是单线程的情况, 单线程中执行流只有一个, 两次相同的if判断其实是没有必要的, 但是多线程的条件下, 是多个执行流, 相同的逻辑判断条件也可能产生不同的结果

完整代码(变量volatile)

关于变量是否会产生指令重排序和内存可见性问题, 我们直接加上volatile即可

/*** 下面定义一个类来测试懒汉式单例模式(完整改进版)*/
class LazySingleton {// 提供一个静态的变量用来返回private volatile static LazySingleton lazySingleton = null;// 构造方法私有化(不可以在外部new对象)private LazySingleton() {}// 提供一个公开的获取实例的接口public static LazySingleton getInstance() {// 我们把if判断和new对象通过加锁打包为一个原子性的操作(这里使用类对象锁)if (lazySingleton == null) {synchronized (LazySingleton.class) {if (lazySingleton == null) {lazySingleton = new LazySingleton();}}}return lazySingleton;}
}

阻塞队列

生产者消费者模型

关于生产者消费者模型, 其实是生活中抽象出来的一个模型案例, 我们举一个包饺子的例子来简单解释一下

在包饺子的过程中, 存在一个擀饺子皮的人, 我们称之为生产者, 擀出来的饺子皮放到一个竹盘上, 这个竹盘相当于一个中间的媒介, 生产者生产的物质在上面与消费者进行交互, 而包饺子的人就是一个消费者, 从中间媒介中取出东西, 也就是消费的过程, 我们的中间的竹盘相当于一个缓冲, 如果包饺子的人包的快的话, 就需要等待做饺子皮的人, 如果做饺子皮的人做的快的话, 当竹盘放不下的时候就需要阻塞等待
上面的情景抽象成生产者消费者模型, 擀饺子皮的人是生产者, 竹盖是阻塞队列, 包饺子的人是消费者