初始JavaEE篇——多线程(4):wait、notify,饿汉模式,懒汉模式,指令重排序

找往期文章包括但不限于本期文章中不懂的知识点:

个人主页:我要学编程(ಥ_ಥ)-CSDN博客

所属专栏:JavaEE

目录

wait、notify 方法

多线程练习

单例模式

饿汉模式

懒汉模式

指令重排序 


wait、notify 方法

wait 和 我们前面学习的sleep、join方法一样,也是让线程阻塞,但是其可以被notify方法唤醒,但是sleep是被Interrupt给提前唤醒或者指定时间过了之后自动被唤醒,并且会抛出异常。且 join 是一个线程等待另一个线程,并且要 被等待的线程彻底执行完成之后,等待的线程才会从阻塞的中被唤醒重新执行。

wait方法在使用时,要和synchronized一起搭配使用,因为其是先对调用它的对象进行解锁,阻塞,在被唤醒之后,在进行加锁操作。

public class Test {
    public static void main(String[] args) throws InterruptedException {
        Object locker1 = new Object();
        Thread t = new Thread(()->{
            System.out.println("wait之前");
            synchronized (locker1) { // 加锁
                try {
                    locker1.wait(); // 进入wait方法解锁,出wait方法加锁
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            System.out.println("wait之后");
        });
        t.start();
        // 为了让t线程先wait阻塞等待,得先休眠主线程一会:
        // 可以使用sleep方法,也可以使用IO的方法阻塞
        Thread.sleep(1000);
        System.out.println("输入任意内容,唤醒t线程");
        Scanner scanner = new Scanner(System.in);
        scanner.next();
        // 要出wait方法就需要notify进行唤醒操作
        synchronized (locker1) {
            locker1.notify();
        }
    }
}

注意:

1、在Java中,wait 和 notify 方法一定是和 synchronized 一起使用的。

2、在1的基础上,四者的进行加锁解锁的操作一定是针对同一个锁对象。

3、notify 的唤醒操作一定是在 wait 之前才能有效的唤醒。如果先执行了 notify 的唤醒操作,但是 还没有执行wait的阻塞操作的话,那么线程就一直会阻塞,但是 notify 的唤醒操作对线程本身是不会有影响的。

4、wait 和 notify 方法是 Object 对象的方法,即所有对象都可以使用这两个方法。

5、如果有多个线程处于 wait 的阻塞状态,那么 notify 一次只能随机唤醒一个线程。如果想要全部唤醒的话,得使用 notifyAll 方法。当然,也可以使用 notifyAll 去唤醒一个线程。

6、wait 和 join一样,也提供了最大等待时间。当超出这个最大等待时间时,被 wait 方法阻塞的线程将不会在处于阻塞状态。

public class Test {
    public static void main(String[] args) throws InterruptedException {
        Object locker = new Object();
        Thread t = new Thread(()->{
            System.out.println("wait之前");
            synchronized (locker) {
                try {
                    locker.wait(5000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            System.out.println("wait之后");
            System.out.println("t线程结束");
        });

        t.start();
        Thread.sleep(1000);
        System.out.println("输入任意内容,唤醒t线程");
        Scanner scanner = new Scanner(System.in);
        scanner.next();
        synchronized (locker) {
            locker.notify();
        }
    }
}

当我们迟迟没有去输入值时,如果已经超过了 wait 的最大阻塞时间的话, wait 便不会去阻塞 t 线程了,而是会让其继续执行下去,即使我们后续再次输入值来执行 notify 的唤醒操作,也不再有用了。

7、当一个线程执行到 wait 之后,这个锁被释放了,也就意味着有别的线程可以使用这把锁了。 

多线程练习

到此为止,我们已经学习了不少的多线程知识,现在我们就来练习一下。

题目:

有三个线程:t1、t2、t3,三者分别打印A、B、C,现在我们需要打印10次ABC。 

思路:

1、既然打印有先后顺序,那么我们肯定是可以通过手动控制sleep 的休眠时间来决定的。

2、刚刚我们学习了 wait 和 notify ,应该是可以想到这个应用场景的,完全对上了。一个 打印完A之后,唤醒另一个线程,打印B,接着唤醒另一个线程打印C,最后 t3线程唤醒 t1线程,就这样相互唤醒打印,而 main 线程用来唤醒 t1 线程开始最初的打印即可。

代码实现:

1、暴力-sleep:

public class Test {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.print("A");
            }
        });

        Thread t2 = new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.print("B");
            }
        });

        Thread t3 = new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("C");
            }
        });

        t1.start();
        Thread.sleep(10); // 确保 t1是最先执行的
        t2.start();
        Thread.sleep(10); // 确保 t2比t1后执行,比t3先执行
        t3.start();
    }
}

注意:这里使三个线程的执行顺序的确定,其休眠的时间不能过长,否则不好衔接。 

2、wait-notify版本:

public class Test {
    public static void main(String[] args) throws InterruptedException {
        Object locker1 = new Object();
        Object locker2 = new Object();
        Object locker3 = new Object();

        Thread t1 = new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) {
                    synchronized (locker1) {
                        locker1.wait();
                    }
                    System.out.print("A");
                    synchronized (locker2) { // 要清楚唤醒的是哪个线程
                        locker2.notify();
                    }
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });

        Thread t2 = new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) {
                    synchronized (locker2) {
                        locker2.wait();
                    }
                    System.out.print("B");
                    synchronized (locker3) { // 要清楚唤醒的是哪个线程
                        locker3.notify();
                    }
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });

        Thread t3 = new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) {
                    synchronized (locker3) {
                        locker3.wait();
                    }
                    System.out.println("C");
                    synchronized (locker1) { // 要清楚唤醒的是哪个线程
                        locker1.notify();
                    }
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });

        t1.start();
        t2.start();
        t3.start();
        // 确保t1先执行到了wait
        Thread.sleep(1000);
        synchronized (locker1) { // notify一定要和synchronized配合使用
            locker1.notify();
        }
    }
}

单例模式

单例模式属于设计模式的一种,是指一个进程中,一个类只能实例化一个对象,即单个实例。那怎么去实现一个进程中只能有一个对象呢?直接把构造方法改为private即可,这样在外部就不能创建实例了。 

单例模式中,最常见的就是饿汉模式与懒汉模式。 

饿汉模式

饿汉模式,主要体现在"饿"字上,因为其是迫不及待的去创建类的实例。

代码演示:

// 饿汉模式
class SingleTon {
    // 迫不及待的创建实例
    private static SingleTon singleTon = new SingleTon();

    public static SingleTon getInstance() {
        return singleTon;
    }

    // 单例模式的构造方法一定是private修饰的
    private SingleTon() {

    }
}

这里创建类的实例是通过创建一个静态的成员变量来实现的,而静态的成员变量是类在加载时,就会被创建,即JVM中有这个类存在的痕迹的话,那么这个实例就会存在。 因此,以"饿"得名。

我们也可以去检查这个饿汉模式是否创建成功,主要检查是否是单例模式。

public class Test {
    public static void main(String[] args) {
        // SingleTon s = new SingleTon(); // error

        SingleTon s1 = SingleTon.getInstance();
        SingleTon s2 = SingleTon.getInstance();
        System.out.println(s1 == s2); // true
    }
}

从上面的程序运行的结果,可以得知:一个进程中不能实例化多个对象,符合单例模式的特征。

懒汉模式

懒汉模式,主要体现在"懒"字上,只有当迫不得已时,才去创建实例。

代码演示:

// 懒汉模式
class SingleTonLazy {
    // 迫不得已才创建实例
    private static SingleTonLazy singleTonLazy = null;

    public static SingleTonLazy getInstance() {
        if (singleTonLazy == null) {
            singleTonLazy = new SingleTonLazy(); // 一定要把对象保留下来
        }
        return singleTonLazy;
    }

    // 单例模式的构造方法一定是私有的
    private SingleTonLazy() {

    }
}

懒汉模式只有当外部调用getInstance方法时,才会去创建实例,否则就不会创建实例。 

同样也可以去测试这个懒汉模式是否创建成功。

public class Test {
    public static void main(String[] args) {
        // SingleTonLazy s = new SingleTonLazy(); // error

        SingleTonLazy s1 = SingleTonLazy.getInstance();
        SingleTonLazy s2 = SingleTonLazy.getInstance();
        System.out.println(s1 == s2); // true
    }
}

上面的懒汉模式在单线程下使用没问题,但是在多线程下使用,便会出现线程安全问题。(饿汉模式之所没有线程安全问题,是因为饿汉模式只是进行return的"读"操作,而不是和懒汉模式一样,有"写"操作)

因为懒汉模式的创建线程虽然只是一个赋值代码,也就是对应一条CPU指令,但是有了 if 语句之后,两者就不算是原子的了。

例如,当线程1去实例化一个对象时,执行到 if 语句,但偏偏此时操作系统将其从CPU上踢下去了,然后线程2就也去CPU上执行了实例化对象的操作,和线程1一样只是执行到 if 语句,也被赶下去了,接着 线程1执行了赋值语句成功的创建了一个对象,然后线程2又被调度到CPU上了,也执行了创建对象的赋值语句。

上面就会导致两个问题:

1、 这里new了两次,即创建了两次对象破坏了单例模式的初衷。

2、后一次new的对象会覆盖前面的对象,可以会对程序的数据造成影响,最终导致程序崩溃。

这里有小伙伴可能会疑惑:为什么线程1创建了对象之后,线程2还会去创建对象呢?因为线程1创建完成之后,线程2已经执行到了 if 语句之中,其认为还没有创建对象。

因此,我们得对上述代码进行加锁操作。

// 懒汉模式
class SingleTonLazy {
    // 迫不得已才创建实例
    private static SingleTonLazy singleTonLazy = null;
    private static Object locker = new Object();

    public static SingleTonLazy getInstance() {
        synchronized (locker) {
            if (singleTonLazy == null) {
                singleTonLazy = new SingleTonLazy(); // 一定要把对象保留下来
            }
        }
        return singleTonLazy;
    }

    // 单例模式的构造方法一定是私有的
    private SingleTonLazy() {

    }
}

加锁操作确实可以实现线程安全,但是它也会造成程序的性能下降,因为当对象的实例被创建出来后,别的线程再去调用这个方法时,就会进行加锁操作,而加锁对于最终的结果来说没影响,也就是加锁加了个寂寞,这就是在浪费时间了。因此,也就导致了性能下降了。

我们的解决方法是在锁的最外层再加上一个 if 语句去判断,这样即使有了实例之后,别的线程再尝试去创建实例时,就会直接return,而不会再去进行加锁操作了,这样性能就提升了不少。

    public static SingleTonLazy getInstance() {
        if (singleTonLazy == null) {
            synchronized (locker) {
                if (singleTonLazy == null) {
                    singleTonLazy = new SingleTonLazy(); // 一定要把对象保留下来
                }
            }
        }
        return singleTonLazy;
    }

指令重排序 

上面的懒汉模式代码,还是有点问题,这个问题和指令重排序有关。

概念:指令重排序是指在不影响代码的执行逻辑的基础上,编译器对要执行的代码其底层对应的计算机指令进行了优化处理,会使其与原来的执行顺序不一致。

懒汉模式的指令重排序体现在 赋值语句。我们先来学习一下,这个赋值语句,其底层对应的逻辑:1、向内存申请了一块空间;2、在这块空间内构造对象(初始化成员变量等)3、将这块空间的首地址给到引用变量。如果将上述三个操作类比到我们日常生活的话,那就是1、买房子;2、装修;3、拿到钥匙。

指令重排序可能会使这个1、2、3的顺序打乱,变成1、3、2。虽然这个在日常生活中,即使打乱之后,我们也是不会直接入住的,因为还没有装修,但是计算机可不一样,它是一个铁憨憨,他只知道执行工作,因此当它执行了1、3之后,也就是拿到了这个对象的引用之后,如果此时操作系统将其从CPU上踢下去了,让别的线程来执行相关方法的话,这个操作就不亚于在毛坯房中直接拎包入住的行为了。这可能直接就把程序给搞崩溃了。因此,我们不能让指令重排序的行为发生,这里就需要用到 volatile 关键字了。这个关键字既可以避免 内存可见性的问题,也可以避免指令重排序的问题。

private static volatile SingleTonLazy singleTonLazy = null;

好啦!本期 初始JavaEE篇——多线程(4):wait、notify,饿汉模式,懒汉模式,指令重排序 的学习之旅 就到此结束啦!我们下一期再一起学习吧!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/906914.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

新工具可绕过 Google Chrome 的新 Cookie 加密系统

一位研究人员发布了一款工具&#xff0c;用于绕过 Google 新推出的 App-Bound 加密 cookie 盗窃防御措施并从 Chrome 网络浏览器中提取已保存的凭据。 这款工具名为“Chrome-App-Bound-Encryption-Decryption”&#xff0c;由网络安全研究员亚历山大哈格纳 (Alexander Hagenah…

JavaSE笔记4】API、包、String类、Object类

目录 一、API 二、包 2.导入不同包下的同名程序 三、String 1. String类是什么&#xff1f; 2. 如何创建String对象?(常用的四种方法&#xff09; 3. String API a. 遍历字符串 b. 判断字符串内容是否相等&#xff1a; c. 截取子串 d. 替换部分内容 e. 匹配子串 f. 匹配开头字…

【含文档】基于ssm+jsp的超市订单后台理系统(含源码+数据库+lw)

1.开发环境 开发系统:Windows10/11 架构模式:MVC/前后端分离 JDK版本: Java JDK1.8 开发工具:IDEA 数据库版本: mysql5.7或8.0 数据库可视化工具: navicat 服务器: apache tomcat 主要技术: Java,Spring,SpringMvc,mybatis,mysql,vue 2.视频演示地址 3.功能 该系统有两个主…

雷军救WPS“三次”,WPS注入新生力量,不再“抄袭”微软

救WPS“三次” 1989年&#xff0c;求伯君用128万行代码编写出了WPS1.0&#xff0c;宣告了中国自主办公时代的开启。 那时候&#xff0c;雷军还在武汉大学深造&#xff0c;他早就把求伯君当成了自己的榜样&#xff0c;这一来二去的&#xff0c;雷军和WPS之间也就结下了不解之缘…

MySQL中,如何定位慢查询?定位到的慢SQL如何分析?

目录 1. 慢查询发生的场景&#xff1f; 2. MySQL中&#xff0c;如何定位慢查询&#xff1f; 2.1 详细解释 3. 定位到的慢SQL如何分析&#xff1f; 3.1 详细说明 1. 慢查询发生的场景&#xff1f; 2. MySQL中&#xff0c;如何定位慢查询&#xff1f; 介绍一下当时产生问题…

Java基于微信小程序的私家车位共享系统(附源码,文档)

博主介绍&#xff1a;✌stormjun、8年大厂程序员经历。全网粉丝15w、csdn博客专家、掘金/华为云/阿里云/InfoQ等平台优质作者、专注于Java技术领域和毕业项目实战✌ &#x1f345;文末获取源码联系&#x1f345; &#x1f447;&#x1f3fb; 精彩专栏推荐订阅&#x1f447;&…

MiniPCIe 接口 CANFD卡

概述 基于MiniPCIe高性能接口CANFD卡采用标准MiniPCIe接口尺寸设计&#xff0c;方便PC机或嵌入式设备快速拓展出CANFD接口&#xff0c;实现数据采集与数据处理。 兼容高速CAN和CANFD两种通信需求、支持CAN2.0A、CAN2.0B协议&#xff0c;符合ISO11898-1规范。 规格 PC接口&…

kafka实时返回浏览数据

在安装完kafka(Docker安装kafka_docker 部署kafka-CSDN博客)&#xff0c;查看容器是否启动&#xff1a; docker ps | grep -E kafka|zookeeper 再用python开启服务 from fastapi import FastAPI, Request from kafka import KafkaProducer import kafka import json import …

Docker Compose一键部署Spring Boot + Vue项目

目录 前提条件 概述 Compose简介 Compose文件 Compose环境 Compose命令 帮助命令 关键命令 Compose部署项目 初始化环境 查看代码文件 sql数据准备 nginx配置文件准备 创建 compose.yaml 一键启动compose多个容器 浏览器访问虚拟机ip:80(可省略默认的80端口) …

Android——横屏竖屏

系统配置变更的处理机制 为了避免横竖屏切换时重新加载界面的情况&#xff0c;Android设计了一中配置变更机制&#xff0c;在指定的环境配置发生变更之时&#xff0c;无需重启活动页面&#xff0c;只需执行特定的变更行为。该机制的视线过程分为两步&#xff1a; 修改 Androi…

【前端基础】CSS进阶

目标&#xff1a;掌握复合选择器作用和写法&#xff1b;使用background属性添加背景效果 01-复合选择器 定义&#xff1a;由两个或多个基础选择器&#xff0c;通过不同的方式组合而成。 作用&#xff1a;更准确、更高效的选择目标元素&#xff08;标签&#xff09;。 后代选…

Chrome与火狐的安全功能全面评估

在当今数字化时代&#xff0c;网络安全已成为用户最为关注的问题之一。作为两款广受欢迎的浏览器&#xff0c;Chrome和火狐&#xff08;Firefox&#xff09;都提供了多种安全功能来保护用户的在线隐私和数据安全。本文将全面评估这两款浏览器的安全功能&#xff0c;帮助用户更好…

动态代理:面向接口编程,屏蔽RPC处理过程

RPC远程调用 使用 RPC 时&#xff0c;一般的做法是先找服务提供方要接口&#xff0c;通过 Maven把接口依赖到项目中。在编写业务逻辑的时候&#xff0c;如果要调用提供方的接口&#xff0c;只需要通过依赖注入的方式把接口注入到项目中&#xff0c;然后在代码里面直接调用接口…

VsCode中搭建 Rt-Thread 开发环境(编译,调试,下载)

VsCode中搭建 Rt-Thread 开发环境&#xff08;编译&#xff0c;调试&#xff0c;下载&#xff09; 文章目录 VsCode中搭建 Rt-Thread 开发环境&#xff08;编译&#xff0c;调试&#xff0c;下载&#xff09;一 . 下载rt-thread源码二. 安装env脚本环境三 . 配置工具链3.1 使用…

Node.js:Express 中间件 CORS 跨域资源共享

Node.js&#xff1a;Express 中间件 & CORS 中间件全局中间件局部中间件分类错误级中间件内置中间件 CORS原理预检请求 中间件 中间件是不直接接收请求&#xff0c;也不直接发送响应&#xff0c;而是在这之间处理一个中间过程的组件。 当一个请求到来&#xff0c;会经过多…

OPENAI官方prompt文档解析

官方文档地址:https://platform.openai.com/docs/guides/gpt-best-practices 文档中文版来源:OpenAI 官方提示工程指南 [译] | 宝玉的分享 (baoyu.io) 1.写清楚说明 如果prompt给的范围十分模糊或是过于宽泛,那么GPT就会开始猜测您想要的内容,从而导致生成的结果偏离预期. …

ubuntu安装与配置Nginx(1)

在 Ubuntu 上安装和配置 Nginx 是相对简单的。以下是一个逐步指南&#xff1a; 1. 更新系统包 首先&#xff0c;确保你的系统是最新的。打开终端并运行&#xff1a; sudo apt update sudo apt upgrade2. 安装 Nginx 使用以下命令安装 Nginx&#xff1a; sudo apt install …

NVR设备ONVIF接入平台EasyCVR视频分析设备平台视频质量诊断技术与能力

视频诊断技术是一种智能化的视频故障分析与预警系统&#xff0c;NVR设备ONVIF接入平台EasyCVR通过对前端设备传回的码流进行解码以及图像质量评估&#xff0c;对视频图像中存在的质量问题进行智能分析、判断和预警。这项技术在安防监控领域尤为重要&#xff0c;因为它能够确保监…

【机器学习】20. RNN - Recurrent Neural Networks 和 LSTM

1. RNN定义 用于顺序数据 文本数据是序列数据的一个例子 句子是单词的序列——一个单词接另一个单词 每个句子可能有不同数量的单词&#xff08;长度可变&#xff09; 每个句子之间可能有长距离的依赖关系 rnn可以记住序列中较早的相关信息 RNN在每个时间点取序列中的1个…

ElementUI el-form表单多层数组的校验

问题描述 提示&#xff1a;这里描述项目中遇到的问题&#xff1a; ElementUI el-form表单多层数组的校验 页面效果&#xff1a; 数据结构&#xff1a; addform: {code: ,type: ,value: ,state: 1,remark: ,fieldList: [{fieldCode: ,resolverEntities: [{resolverType: , re…