juc-03-synchronized、notify、notifyAll、wait、volatile

notify、notifyAll、wait 这三个方法都是 Object 类中定义的方法。
前提: 持有当前对象的锁，才能调用当前的对象的notify、notifyAll、wait 这三个方法。

• wait() 等待，当业务执行的某个条件不成立时，执行wait()方法，放弃持有的锁，阻塞当前的线程，等待需要的条件成立。
• notify/notifyAll 唤醒，唤醒的是所有等待当前锁的线程，这些线程重新回到就绪状态，争抢cpu资源。

//生产者
public class Producer implements Runnable{

    private Factory factory;

    public Producer(Factory factory) {
 this.factory = factory;
    }

    @Override
    public void run() {
 // 每个生产者生产3次
 for (int i = 0; i < 3; i++) {
     try {
  // 生产时间设置 200 ms
  TimeUnit.MILLISECONDS.sleep(200);
  // 生产者，通过 factory 类生产
  factory.produce();
     } catch (InterruptedException e) {
  e.printStackTrace();
     }
 }
    }
}

// 消费者
public class Consumer implements Runnable {

    private Factory factory;

    public Consumer(Factory factory) {
 this.factory = factory;
    }

    @Override
    public void run() {
 // 每个消费者生产3次
 for (int i = 0; i < 3; i++) {
     try {
  // 消费时间设置 200 ms
  TimeUnit.MILLISECONDS.sleep(200);
  // 消费者通过 factory 消费
  factory.consume();
     } catch (InterruptedException e) {
  e.printStackTrace();
     }
 }
    }
}

//工厂
public class Factory {

    // 可生产的最大数量
    private final int maxCount = 5;

    // 当前已有数量
    private int curCount;

    
    public synchronized void produce() throws InterruptedException {
 // 抢到锁
 while (curCount >= maxCount) {
     System.out.println("生产已满，等待消费--" + Thread.currentThread().getName());
     // wait() 释放当前持有的锁
     this.wait();
 }
 this.curCount++;
 System.out.println(Thread.currentThread().getName() + "生产，当前数量--" + curCount);
 // 唤醒当前正在阻塞等待this对象锁的线程
 this.notifyAll();
    }

    
    public synchronized void consume() throws InterruptedException {
 while (curCount <= 0) {
     System.out.println("无货消费，等待生产====" + Thread.currentThread().getName());
     // wait() 释放当前持有的锁
     this.wait();
 }
 this.curCount--;
 System.out.println(Thread.currentThread().getName() + "消费，当前剩余数量--" + curCount);
 // 唤醒当前正在阻塞等待this对象锁的线程
 this.notifyAll();
    }
}

// 测试生产者消费者
public class TestProducerConsumer {

    @Test
    public void testProducerConsumer() throws InterruptedException {
 Factory factory = new Factory();
 new Thread(new Producer(factory), "生产者A").start();
 new Thread(new Producer(factory), "生产者B").start();
 new Thread(new Producer(factory), "生产者C").start();
 new Thread(new Consumer(factory), "消费者1").start();
 new Thread(new Consumer(factory), "消费者2").start();
 new Thread(new Consumer(factory), "消费者3").start();
 TimeUnit.SECONDS.sleep(20);
    }
}

生产者C生产，当前数量--1
生产者A生产，当前数量--2
生产者B生产，当前数量--3
消费者2消费，当前剩余数量--2
消费者3消费，当前剩余数量--1
消费者1消费，当前剩余数量--0
生产者A生产，当前数量--1
生产者B生产，当前数量--2
消费者1消费，当前剩余数量--1
生产者C生产，当前数量--2
消费者3消费，当前剩余数量--1
消费者2消费，当前剩余数量--0
无货消费，等待生产====消费者3
生产者C生产，当前数量--1
消费者1消费，当前剩余数量--0
无货消费，等待生产====消费者2
生产者B生产，当前数量--1
生产者A生产，当前数量--2
消费者2消费，当前剩余数量--1
消费者3消费，当前剩余数量--0

public class TestVolatile {

    public static void main(String[] args) throws InterruptedException {
 FlagThread thread = new FlagThread();
 thread.start();
 while (!thread.isFlag()){
     if(thread.isFlag()){
  System.out.println("读取到 flag = true");
  break;
     }
 }
    }
}

class FlagThread extends Thread {

    private boolean flag;

    public boolean isFlag() {
 return flag;
    }

    @Override
    public void run() {
 try {
     TimeUnit.MILLISECONDS.sleep(100);
 } catch (InterruptedException e) {
     e.printStackTrace();
 }
 this.flag = true;
    }
}

public class TestVolatile {

    public static void main(String[] args) throws InterruptedException {
 FlagThread thread = new FlagThread();
 thread.start();
 while (!thread.isFlag()){
     if(thread.isFlag()){
  System.out.println("读取到 flag = true");
  break;
     }
 }
    }
}

class FlagThread extends Thread {

    // 使用 volatile 修饰变量，保证变量修改后，线程间可见
    private volatile boolean flag;

    public boolean isFlag() {
 return flag;
    }

    @Override
    public void run() {
 try {
     TimeUnit.MILLISECONDS.sleep(100);
 } catch (InterruptedException e) {
     e.printStackTrace();
 }
 this.flag = true;
    }
}

读取到 flag = true