[Java EE] 多线程(四):线程安全问题(下)

Mr.Demo.2024-05-01 15:13

1.5 volatile关键字

我们在了解这个关键字之前,我们首先要把产生线程安全的第4个原因补齐,我们来说说由于内存可见性 引起的线程安全问题.

我们来看下面这样一段代码:

java 复制代码 
import java.util.Scanner;

public class Demo16 {
    public static int count = 0;
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            while (count == 0) {
                ;
            }
            System.out.println("count的值被修改");
        });
        Thread thread1 = new Thread(()->{
            Scanner scanner = new Scanner(System.in);
            count = scanner.nextInt();
        });
        thread.start();
        Thread.sleep(1000);
        thread1.start();
    }
}

由上述代码的逻辑,我们预期的结果是:在控制台的地方输入了一个不为0的数字的时候,上面的循环条件不满足,跳出循环,打印"count的值被修改",但是我们运行起来发现:

输入了不为0的值之后,毛都没有!!

为什么会出现这种情况呢?我们首先要了解一下Java中的内存模型(JMM),即Java虚拟机规范中定义的Java内存模型.

设计这种内存模型的目的就是为了保证:屏蔽掉各种硬件和操作系统的访问差异,避免由于操作系统不同和硬件结构的不同而引起的不兼容,真正做到"一次编译,到处运行".

  • 线程之间的共享变量存在主内存(Main Memory).(硬件角度总真正的内存空间)
  • 每⼀个线程都有自己的"⼯作内存"(Working Memory).(硬件角度的CPU中的寄存器)
  • 线程想要读取一个共享变量的时候,需要先从主内存中拷贝到工作内存中.
  • 线程想要修改一个共享变量的时候,先修改工作内存中的副本,再同步回主内存中.

但是当计算机发现每次从主内存中拷贝数据到工作内存中时,每次拷贝的数据都是一样的,而且工作内存的访问要比主内存的访问快好几个数量级,这就使得计算机不得不做出优化操作,每次读取变量的时候,把拷贝这一步优化掉了,直接读取的是工作内存中的数据,这就使得在另一个线程在主内存中修改这个共享变量的时候,另一个线程读取不到,也就无法改变工作内存中的数据.

但是我们在循环中加上一个print操作的时候,我们会惊奇地发现,循环可以停下来了:

java 复制代码 
import java.util.Scanner;
public class Demo17 {
    public static int count = 0;
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            while (count == 0) {
                System.out.println("tread");//IO输出比count判断慢得多
            }
            System.out.println("count的值被修改");
        });
        Thread thread1 = new Thread(()->{
            Scanner scanner = new Scanner(System.in);
            count = scanner.nextInt();
        });
        thread.start();
        Thread.sleep(1000);
        thread1.start();
    }
}

这又是为什么呢?是因为由于拷贝操作时内存方面的操作,速度肯定又要比IO操作快好几个数量级.而IO操作每次执行的结果注定是不同的,这就使得JVM不可以优化掉IO操作,即然IO操作都优化不到,比他快好几个数量级的拷贝操作肯定优化不到.

举例说明:年会不能停

有请助教:潘妮,马杰克,胡建林,杰弗瑞.

假如现在没有胡建林,现在潘妮就相当于主内存与工作内存中的拷贝操作,马杰克就相当于直接从工作内存中读取的操作.如今杰弗瑞要裁员,由于马杰克的工作效率和工作能力比潘妮大上好几个数量级,裁员的时候优先裁的就是潘妮,但是现在歪打正着混进个胡建林,就相当于IO操作,由于胡建林是靠着"关系"进入的众和集团,即使胡建林干活再慢,也不可以裁掉,即然比潘妮干活慢的胡建林都裁不掉,何谈裁潘妮.

现在如果没有IO操作,还想要while循环停下来,我们就可以引入volatile关键字来对变量进行修饰 .告诉JVM,该变量必须每次都到主内存中读取,不可以进行优化操作,就相当于告诉老板,裁员的时候请不要裁到大动脉!!!

java 复制代码 
import java.util.Scanner;

public class Demo18 {
    public static volatile int count = 0;//使用volatile告诉编译器该变量不可优化
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            while (count == 0) {
                ;
            }
            System.out.println("count的值被修改");
        });
        Thread thread1 = new Thread(()->{
            Scanner scanner = new Scanner(System.in);
            count = scanner.nextInt();
        });
        thread.start();
        Thread.sleep(1000);
        thread1.start();
    }
}

但是我们需要注意的是:volatile不保证原子性

java 复制代码 
public class Demo21 {
    public static volatile int count = 0;
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            for (int i = 0; i < 50000; i++) {
                count++;
            }
        });
        Thread thread1 = new Thread(()->{
            for (int i = 0; i < 50000; i++) {
                count++;
            }
        });
        thread.start();
        thread1.start();
        thread.join();
        thread1.join();
        System.out.println(count);
    }
}

我们看到,即使给count变量加了volatile关键字,还是会存在线程安全问题.

1.6 wait与notify-->线程的等待通知机制

由于线程之间是抢占式执行的,因此线程之间执行的先后顺序难以预知.

但是实际开发中有时候我们希望合理的协调多个线程之间的执行先后顺序.

举例说明:光与影

有请助教:黑子哲也,青峰大辉,火神大我

在与漂亮国的对决中,他们像拿到一个二分球,就先需要大辉先抢球,之后传球给黑子,黑子通过回旋一击,使得篮球改变运动轨迹,之后通过大我的扣篮完成完美一击.

他们中间的先后顺序,但凡慢了一步,或者是快了一步,都会丢失这2分.

完成这里的协调工作,需要涉及到三个方法:

  • wait()/wait(time):让线程进入等待状态
  • notify()/notifyAll():唤醒在当前对象上 等待的所有线程
    注意:这几个方法都是Object类的方法

1.6.1 wait()方法

wait做的事情:

  • 释放当前对象的锁
  • 使得当前线程进入阻塞等待状态
  • 满足一定条件被唤醒之后,尝试重新获取锁
    注意:wait要搭配synchronized使用,否者在wait()方法解锁的时候,找不到对应的锁,就会抛出异常.
    wait结束等待的条件:
  • 其他线程使用调用notify方法唤醒该线程.
  • wait时间超时.
  • 其他线程调用该线程的interrupted方法,导致线程被强制唤醒,抛出异常.

1.6.2 notify()方法

notify⽅法是唤醒等待的线程.

• ⽅法notify()也要在同步⽅法或同步块中调⽤，该⽅法是⽤来通知那些可能等待该对象的对象锁的其它线程，对其发出通知notify，并使它们重新获取该对象的对象锁。

• 如果有多个线程等待，则有线程调度器随机挑选出⼀个呈wait状态的线程。(并没有"先来后到")

• 在notify()⽅法后，当前线程不会⻢上释放该对象锁，要等到执⾏notify()⽅法的线程将程序执⾏
完，也就是退出同步代码块之后才会释放对象锁。

使用示例:

java 复制代码 
public class Demo19 {
    public static void main(String[] args) throws InterruptedException {
        Object object = new Object();
        Thread thread = new Thread(()->{
            synchronized (object){
                System.out.println("等待开始");
                try {
                    object.wait();//1.解锁,此时tread1才可以加锁 2.阻塞等待 3.唤醒之后再尝试获取锁 4.唤醒之后tread1未解除锁,阻塞
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("等待结束");//所以等待结束的打印一定在唤醒结束之后
            }
        });
        Thread thread1 = new Thread(()->{
            synchronized (object){
                System.out.println("唤醒开始");
                object.notify();
                System.out.println("唤醒结束");
            }
        });
        thread.start();
        Thread.sleep(1000);
        thread1.start();
    }
}

注意：在tread启动之后，必须sleep1s，由于线程调度的随机性，不加的话很可能先调度tread1现成，这样notify就会被wait错过

1.6.3 notifyAll()方法

上述notify方法只能随机唤醒一个线程:

java 复制代码 
public class Demo20 {
    public static void main(String[] args) throws InterruptedException {
        Object object = new Object();
        Thread thread = new Thread(()->{
            synchronized (object){
                System.out.println("等待开始");
                try {
                    object.wait();//1.解锁,此时tread1才可以加锁 2.阻塞等待 3.唤醒之后再尝试获取锁 4.唤醒之后tread1未解除锁,阻塞
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("等待结束");//所以等待结束的打印一定在唤醒结束之后
            }
        });
        Thread thread2 = new Thread(()->{
            synchronized (object){
                System.out.println("等待开始1");
                try {
                    object.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("等待结束1");
            }
        });
        Thread thread1 = new Thread(()->{
            synchronized (object){
                System.out.println("唤醒开始");
                object.notify();
                System.out.println("唤醒结束");
            }
        });
        thread.start();
        thread2.start();
        Thread.sleep(1000);
        thread1.start();
    }
}

运行结果:只唤醒了tread线程

如果想要一次性唤醒所有线程,就要用到notifyAll()方法:

java 复制代码 
public class Demo20 {
    public static void main(String[] args) throws InterruptedException {
        Object object = new Object();
        Thread thread = new Thread(()->{
            synchronized (object){
                System.out.println("等待开始");
                try {
                    object.wait();//1.解锁,此时tread1才可以加锁 2.阻塞等待 3.唤醒之后再尝试获取锁 4.唤醒之后tread1未解除锁,阻塞
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("等待结束");//所以等待结束的打印一定在唤醒结束之后
            }
        });
        Thread thread2 = new Thread(()->{
            synchronized (object){
                System.out.println("等待开始1");
                try {
                    object.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("等待结束1");
            }
        });
        Thread thread1 = new Thread(()->{
            synchronized (object){
                System.out.println("唤醒开始");
                object.notifyAll();
                System.out.println("唤醒结束");
            }
        });
        thread.start();
        thread2.start();
        Thread.sleep(1000);
        thread1.start();
    }
}

运行结果:线程全部被唤醒

在两个线程全部被唤醒之后,由于唤醒之后线程会尝试重新获取锁,tread和tread2还是会发生锁竞争.

举例:面试

有请助教:滑稽老铁

notify()方法:

notifyAll()方法:

相关推荐
群联云防护小杜10 分钟前
服务器被挂马怎么办？——解决服务器被挂马的方法和步骤
运维·服务器·网络协议·tcp/ip·安全·ddos
?crying18 分钟前
蓝队基础4 -- 安全运营与监控
网络·安全·web安全
程序猿麦小七19 分钟前
今天给在家介绍一篇基于jsp的旅游网站设计与实现
java·源码·旅游·景区·酒店
SafePloy安策28 分钟前
SM软件加密与授权：构建安全高效的软件保护体系
安全
张某布响丸辣32 分钟前
SQL中的时间类型：深入解析与应用
java·数据库·sql·mysql·oracle
Xlbb.36 分钟前
安全见闻6-9
网络·安全·web安全·网络安全
喜欢打篮球的普通人37 分钟前
rust模式和匹配
java·算法·rust
java小吕布1 小时前
Java中的排序算法：探索与比较
java·后端·算法·排序算法
慢生活的人。1 小时前
SpringSecurity+jwt+captcha登录认证授权总结
java·认证·rbac·权限·验证
向阳12181 小时前
LeetCode40：组合总和II
java·算法·leetcode
热门推荐
01玄机平台应急响应—webshell查杀02Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04液体神经网络：LNN是个啥概念？05文件或文件夹名称中有空格如何批量去除06组基轨迹建模 GBTM的介绍与实现（Stata 或 R）07新版微信小程序获取用户手机号08优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间09基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测102024最新 无人机 数据集（不定期更新）