1、线程通信模型

  • 线程间通信的模型有两种：共享内存和消息传递

2、线程通信方式一：Object.wait() 和 notify()

wait/notify注意事项

  • wait/notify必须在同步代码块或者同步函数中使用
  • wait/notify必须由同一个锁对象调用
  • wait/notify方法属于Object的方法，所以锁对象可以是任意对象

  • notify之后不是表示线程立即恢复执行，因为当初中断的地方是在同步代码块中，而此刻它已经不再持有锁，它需要再去和其他线程抢锁

    • 如果能获取锁，线程WAITING>>>RUNNABLE
    • 获取不到锁，线程WAITING>>>BLOCKED

      生产者、消费者模式

  • 生产者消费者问题（Producer-consumer problem），也称有限缓冲问题（Bounded-buffer problem），是一个多线程同步问题的经典案例。生产者生成一定量的数据放到缓冲区中，然后重复此过程；与此同时，消费者也在缓冲区消耗这些数据。生产者和消费者之间必须保持同步，要保证生产者不会在缓冲区满时放入数据，消费者也不会在缓冲区空时消耗数据。

    1. public class Main {
    2.   public static void main(String[] args) throws InterruptedException {
    4.       Storage storage = new Storage();
    5.       Thread p1 = new Thread(new Producer(storage));
    6.       Thread p2 = new Thread(new Producer(storage));
    7.       Thread p3 = new Thread(new Producer(storage));
    9.       Thread c1 = new Thread(new Consumer(storage));
    10.       Thread c2 = new Thread(new Consumer(storage));
    11.       Thread c3 = new Thread(new Consumer(storage));
    13.       c1.start();
    14.       c2.start();
    15.       c3.start();
    16.       p1.start();
    17.       p2.start();
    18.       p3.start();
    19.   }
    21.   /**
    22.    * 生产者
    23.    */
    24.   public static class Producer extends Thread {
    25.       private Storage storage;
    27.       public Producer(){}
    29.       public Producer(Storage storage){
    30.           this.storage = storage;
    31.       }
    33.       @Override
    34.       public void run(){
    35.           while(true){
    36.               try{
    37.                   Thread.sleep(1000);
    38.                   storage.produce();
    39.               }catch (InterruptedException e){
    40.                   e.printStackTrace();
    41.               }
    42.           }
    43.       }
    44.   }
    46.   /**
    47.    * 消费者
    48.    */
    49.   public static class Consumer extends Thread {
    50.       private Storage storage;
    52.       public Consumer(){}
    54.       public Consumer(Storage storage){
    55.           this.storage = storage;
    56.       }
    58.       @Override
    59.       public void run(){
    60.           while(true){
    61.               try{
    62.                   Thread.sleep(3000);
    63.                   storage.consume();
    64.               }catch (InterruptedException e){
    65.                   e.printStackTrace();
    66.               }
    67.           }
    68.       }
    69.   }
    71.   /**
    72.    * 仓库类
    73.    */
    74.   public static class Storage extends Thread {
    75.       // 仓库容量
    76.       private final int MAX_SIZE = 10;
    77.       // 仓库存储的载体
    78.       private LinkedList<Object> list = new LinkedList<>();
    80.       public void produce() {
    81.           synchronized (list) {
    82.               while (list.size() + 1 > MAX_SIZE) {
    83.                   System.out.println("【生产者" + Thread.currentThread().getName()
    84.                           + "】仓库已满");
    85.                   try {
    86.                       list.wait();
    87.                   } catch (InterruptedException e) {
    88.                       e.printStackTrace();
    89.                   }
    90.               }
    91.               list.add(new Object());
    92.               System.out.println("【生产者" + Thread.currentThread().getName()
    93.                       + "】生产一个产品，现库存" + list.size());
    94.               list.notifyAll();
    95.           }
    96.       }
    98.       public void consume() {
    99.           synchronized (list) {
    100.               while (list.size() == 0) {
    101.                   System.out.println("【消费者" + Thread.currentThread().getName()
    102.                           + "】仓库为空");
    103.                   try {
    104.                       list.wait();
    105.                   } catch (InterruptedException e) {
    106.                       e.printStackTrace();
    107.                   }
    108.               }
    109.               list.remove();
    110.               System.out.println("【消费者" + Thread.currentThread().getName()
    111.                       + "】消费一个产品，现库存" + list.size());
    112.               list.notifyAll();
    113.           }
    114.       }
    115.   }
    116. }