当前位置：首页 > article >正文

【JavaEE】-- 多线程（初阶）3

article 2025/3/7 4:03:47

文章目录

6.volatile 关键字
- 6.1 volatile能保证内存可见性
- - 6.1.1 CPU层面
  - 6.1.2 Java层面
- 6.2 volatile保证有序性
- 6.3 volatile不保证原子性
7. wait 和 notify
- 7.1 wait()方法和notify()方法
- 7.3 notifyAll()方法
- 7.4 wait() 和 sleep() 的对比（面试题）

6.volatile 关键字

public class Demo_601 {
    static int flg = 0;
    public static void main(String[] args) {
        Thread t1 = new Thread(()->{
            System.out.println(Thread.currentThread().getName() + "线程启动");
            while (flg == 0){
                //不停的循环。处理任务。
            }
            System.out.println(Thread.currentThread().getName() + "线程退出");
        },"t1");
        t1.start();


        Thread t2 = new Thread(()->{
            System.out.println(Thread.currentThread().getName() + "线程启动");
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入一个非零的整数");
            flg = scanner.nextInt();
            System.out.println(Thread.currentThread().getName() + "线程退出");
        }, "t2");
        t2.start();
    }
}

输出结果：
在这里插入图片描述

t2线程正常结束，并且已经修改了flg变量的值，但是t1没有结束，整个进程也没有结束，结果不及预期，线程安全问题产生。

问题产生的原因：
在这里插入图片描述

对于线程t1来说，只是比较flg这个变量的值，从来都没有修改过，所以CPU认为，这个值永远也不会改变，从而也不会重新从内存中读取值。

为了提高运行效率这个值一般存在寄存器或CPU的缓存中。

在这里插入图片描述

在Java层面我们叫这块内存是寄存器，在JVM层面我们叫这块内存是工作内存。

在多线程的环境下，就会出现我们看到的这个问题，一个线程修改了另一个线程无法感知到的变量。

6.1 volatile能保证内存可见性

6.1.1 CPU层面

MESI（缓存一致性协议），可以理解为一种通知机制。
在这里插入图片描述
当所有的处理器没有修改共享变量时，各自的处理器只读取自已缓存中的值，从而提升效率。

当某一个处理器往主内存中写回数据的时候，让缓存中的值失效，通知其他处理器从主内存中重新获取新的值。

6.1.2 Java层面

内存屏障：作用是保证指令执行的先后顺序，从而保证内存可见性。
在这里插入图片描述

为变量加上volatile关键字进行修饰之后的输出结果：

6.2 volatile保证有序性

用volatile修饰过的变量，由于前后有内存屏障，保证了指令的执行顺序，也可以理解为告诉编译器，不要进行指令重排。

6.3 volatile不保证原子性

volatile 和 synchronized 有着本质的区别.synchronized能够保证原⼦性,volatile保证的是内存可⻅性.

7. wait 和 notify

wait 和 notify 是Object类中的方法，每个对象都可以调用这个方法
作用：安排线程的执行顺序。

join 和 wait 是两种不同的操作，join是Thread类中的方法，wait 和 notify 是Object 类中的方法。

7.1 wait()方法和notify()方法

public class Demo_602 {
    public static void main(String[] args) {
        Object locker = new Object();
        Thread t1 = new Thread(()->{
            while (true) {
                System.out.println("调用wait（）之前....");
                synchronized (locker){
                    try {
                        locker.wait();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
                System.out.println("wait()唤醒之后...");
                System.out.println("=====================");
            }
        });

        Thread t2 = new Thread(()->{
            while (true) {
                System.out.println("调用notify之前....");
                synchronized (locker){
                    locker.notify();
                }
                System.out.println("调用notify之后....");

                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });

        t1.start();
        t2.start();
    }
}