【JavaEE】【多线程】volatile,wait/notify

目录

• 一、volatile关键字
• • [1.1 内存可见性](#1.1 内存可见性)
  • [1.2 volatile解决内存可见性问题](#1.2 volatile解决内存可见性问题)
• 二、wait和notify
• • [2.1 wait](#2.1 wait)
  • [2.2 notify](#2.2 notify)
  • [2.3 使用例子](#2.3 使用例子)
  • • [2.3.1 例子1](#2.3.1 例子1)
    • [2.3.2 例子二](#2.3.2 例子二)

一、volatile关键字

volatile可以保证内存可见性，只能修饰变量。

1.1 内存可见性

在前面介绍线程不安全原因时介绍到了，在Java中有JMM (Java Memory Model)（Java内存模型）来介绍。

计算机运行代码/程序的时候，访问数据常常要从内存中访问（定义变量时变量就储存在内存中），

然而CPU从内存中读取数据相比于从寄存器中读取数据要慢上很多（几千上万倍），CPU在进行读/写内存的时候速度就会降低。

为了解决这种问题，提高效率，编译器就可能会对代码优化，把一些本来要读取内存的操作，优化为读取寄存器，减少读取内存的次数。这就会导致内存可见性问题。

例如以下代码输入一个不为0的数，本应该打印"threade1结束"，但是并没有。

import java.util.Scanner;
public class Demo {
    public static int isQuite = 0;
    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
           while(isQuite == 0) {
               
           }
            System.out.println("threade1结束");
        }) ;
        Thread thread2 = new Thread(() -> {
            Scanner scanner = new Scanner(System.in);
            isQuite = scanner.nextInt();
        });
        thread1.start();
        thread2.start();
    }
}

以上述代码讲解：

在thread1中while先读取isQuite的值，在进行比较，然而编译器/JVM发现多次得到的isQuite都是0，这个线程也没有修改isQuite操作，然后编译器/JVM就大胆优化只进行第一次的读取isQuite操作，后续直接从寄存器里面读取。

其实编译器/JVM进行优化是不可控的，如果在while循环里面加上sleep，sleep的时间够久了，已经够进行读取操作，可能就不会优化了。

1.2 volatile解决内存可见性问题

如上诉代码，我们直接在isQuite加上volatile修饰，就告诉编译器/JVM不要进行优化，就可以解决问题。

volatile可以解决内存可见性问题，解决不了原子性问题。

import java.util.Scanner;
public class Demo {
	volatile public static int isQuite = 0;
    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
           while(isQuite == 0) {
               
           }
            System.out.println("threade1结束");
        }) ;
        Thread thread2 = new Thread(() -> {
            Scanner scanner = new Scanner(System.in);
            isQuite = scanner.nextInt();
        });
        thread1.start();
        thread2.start();
    }
}

二、wait和notify

在多线程中一个重要的机制是协调各个线程之间的调度顺序，在操作系统是随机调度。

在前面我们介绍了等待一个线程使用join，但是使用join就要等到调用线程结束。而wait不用，wait和notify就是专门协调线程执行逻辑的顺序的。
wait和notify是Object类的成员方法，也就是每一个对象都有。

wait：等待，让指定线程进入阻塞状态。

notify：通知，唤醒对应进入阻塞状态的线程。

2.1 wait

线程饿死/饿死：线程恶死就是指当多个线程竞争一把锁的时候，当线程1拿到了锁，释放锁之后，又由于操作系统的随机调度再次多次让线程1拿到锁，其他线程多次没拿到锁处于阻塞状态，没分配到CPU资源。就相当于鸟妈妈给小鸟喂食，多次喂食都是给一只小鸟，那么其它小鸟就处于饥饿/饿死状态。

我们可以使用wait来避免线程饥饿，当线程拿到锁发现时机不成熟的时候，就可以使用wait让线程进入阻塞状态，等待唤醒。

语法：

synchronized(锁对象) {
	锁对象.wait();
}

注意事项：

• wait()必须搭配synchronized使用：因为wait()的机制就是先释放锁对象的锁，然后等待唤醒在加锁继续执行剩下逻辑。
• 如果对象没有处于加锁状态，就会抛出IllegalMonitorStateException（非法锁状态异常）。
• wait会抛InterruptedException
• wait也有含时间版本，超过时间自动唤醒。
  

2.2 notify

notify就是唤醒wait。

语法：

synchronized(锁对象) {
	锁对象.notify();
}

注意事项：

• notify必须在wait后面执行才能唤醒wait；
• notify和要唤醒的wait要是同一个锁对象；
• 如果有多个线程等待，则有线程调度器随机挑选出一个呈 wait 状态的线程。(并没有 "先来后到")。
• 当有多个线程等待时，可以使用notifyAll()来唤醒所有，但是实际上还是一个一个唤醒。

2.3 使用例子

2.3.1 例子1

题目：使用多线程来打印ABC,一个线程一个字母，打印10个ABC。

解析：线程1唤醒线程2，线程2唤醒线程3，线程3唤醒线程1。主线程中保证先唤醒一下线程1即可。

代码：

public class Demo {
    public static void main(String[] args) throws InterruptedException {
        Object block1 = new Object();
        Object block2 = new Object();
        Object block3 = new Object();

        Thread thread1 = new Thread(() -> {
                try {
                    for (int i = 0; i < 10; i++) {
                        synchronized (block1) {
                            block1.wait();
                        }
                        System.out.print("A");
                        synchronized (block2) {
                            block2.notify();
                        }
                    }
            }catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        Thread thread2 = new Thread(() -> {
                try {
                    for (int i = 0; i < 10; i++) {
                        synchronized (block2) {
                            block2.wait();
                        }
                        System.out.print("B");
                        synchronized (block3) {
                            block3.notify();
                        }
                    }
            }catch (InterruptedException e) {
                    e.printStackTrace();
                }

        });
        Thread thread3 = new Thread(() -> {
                try {
                    for (int i = 0; i < 10; i++) {
                        synchronized (block3) {
                            block3.wait();
                        }
                        System.out.print("C"+" ");
                        synchronized (block1) {
                            block1.notify();
                        }
                    }
            }catch (InterruptedException e) {
                    e.printStackTrace();
                }

        });

        thread1.start();
        thread2.start();
        thread3.start();

        Thread.sleep(1000);
        synchronized (block1) {
            block1.notify();
        }
    }
}

2.3.2 例子二

题目：有三个线程，线程名称分别为：a，b，c。

每个线程打印自己的名称。

需要让他们同时启动，并按 c，b，a的顺序打印。

代码：

public class Demo {
    public static void main(String[] args) throws InterruptedException {
        Object block1 = new Object();
        Object block2 = new Object();
        Object block3 = new Object();

        Thread a = new Thread( () -> {
            Thread.currentThread().setName("a");
            try{
                synchronized (block1) {
                    block1.wait();
                }
                System.out.println(Thread.currentThread().getName());

            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        });
        Thread b = new Thread(() -> {
            Thread.currentThread().setName("b");
            try{
                synchronized (block2) {
                    block2.wait();
                }
                System.out.print(Thread.currentThread().getName()+",");

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (block1) {
                block1.notify();
            }
        });
        Thread c = new Thread(() -> {
            Thread.currentThread().setName("c");
            try{
                synchronized (block3) {
                    block3.wait();
                }
                System.out.print(Thread.currentThread().getName()+",");
                synchronized (block2) {
                    block2.notify();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        a.start();
        b.start();
        c.start();
        Thread.sleep(1000);
        synchronized (block3) {
            block3.notify();
        }
    }
}