【Thread】线程的通信（五）

深藏阁楼爱情的钟 2023-10-02 14:08 19阅读 0赞

### 1. 生产者和消费者问题 ###

生产者和消费者问题：

*  仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品消费；
 *  如果仓库中没有产品，则生产者将产品放入仓库中。否则，停止生产并等待，直到仓库中的产品被消费者取走为止；
 *  如果仓库中放有产品，则消费者可以将产品取走消费。否则，停止消费并等待，直到仓库中再次放入产品为止。

这是一个线程同步问题：生产者和消费者共享同一个资源，并且生产者和消费者之间互相依赖，互为条件。

*  对于生产者：没有生产产品之前，要通知消费者等待，而生产了产品之后，又需要马上通知消费者消费；
 *  对于消费者：在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费。

在生产者与消费者问题中，仅有 `synchronized` 是不够的：

*  `synchronized` 可阻止并发更新同一个共享资源，实现了同步
 *  `synchronized` 不能用来实现不同线程之间的消息传递（通信）

### 2. 线程通信 ###

Java 提供了几个方法解决线程之间的通信问题：

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>wait()</td> 
   <td>表示线程一直等待，直到其它线程通知；与 sleep() 方法不同，它会释放锁</td> 
  </tr> 
  <tr> 
   <td>wail(long timeout)</td> 
   <td>等待的毫秒数</td> 
  </tr> 
  <tr> 
   <td>notify()</td> 
   <td>唤醒一个处于等待状态的线程</td> 
  </tr> 
  <tr> 
   <td>notifyAll()</td> 
   <td>唤醒同一个对象上所有调用 wait() 方法的线程，优先级别高的线程优先调度</td> 
  </tr> 
 </tbody> 
</table>

【注意】：以上方法均是 Object 类中的方法，都只能在同步方法或者同步代码块中调用。否则，会抛出 `IllegalMonitorStateException`

针对以上的“生产者-消费者”问题，有两种解决方法：管程法、信号灯法

#### 2.1 管程法 ####

管程法的原理：生产者将生产好的数据放入缓冲区中，消费者从缓冲区拿出数据

*  生产者：负责生产数据的模块（方法、线程、进程）；
 *  消费者：负责消费数据的模块（方法、线程、进程）；
 *  缓冲区：消费者不能直接使用生产者的数据，它们之间有个“缓冲区”。

生产者：

class Producer extends Thread {
        
    
        private SynContainer container;
    
        public Producer(SynContainer container) {
        
            this.container = container;
        }
    
        @Override
        public void run() {
        
            for (int i = 1; i < 101; i++) {
        
                container.push(new Product(i));
                System.out.println("生产了第" + i + "个产品");
            }
        }
    }

消费者：

class Consumer extends Thread {
        
    
        private SynContainer container;
    
        public Consumer(SynContainer container) {
        
            this.container = container;
        }
    
        @Override
        public void run() {
        
            for (int i = 1; i < 101; i++) {
        
                System.out.println("消费了第" + container.pop().getNum() + "个产品");
            }
        }
    }

产品：

class Product {
        
        // 编号
        private int num;
    
        public Product(int num) {
        
            this.num = num;
        }
    
        public int getNum() {
        
            return num;
        }
    
        public void setNum(int num) {
        
            this.num = num;
        }
    }

缓冲区：

class SynContainer {
        
        // 容器大小
        private Product[] products = new Product[10];
        // 容器计数器
        private int count = 0;
    
        public synchronized void push(Product product) {
        
            if (count == products.length) {
        
                // 通知消费者去消费，生产者等待
                try {
        
                    this.wait();
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }
            // 生产者生产，消费者等待
            products[count] = product;
            count++;
            // 通知消费者消费
            this.notifyAll();
        }
    
        public synchronized Product pop() {
        
            if (count == 0) {
        
                // 通知生产者生产，消费者等待
                try {
        
                    this.wait();
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }
            // 消费者消费
            count--;
            Product p = products[count];
            // 通知生产者生产
            this.notifyAll();
            return p;
        }
    
    }

测试：

public class TestPc {
        
    
        public static void main(String[] args) {
        
            SynContainer container = new SynContainer();
            new Producer(container).start();
            new Consumer(container).start();
        }
    }

#### 2.2 信号灯法 ####

信号灯法原理：通过标志位解决

生产者：

class Player extends Thread {
        
    
        private Tv tv;
    
        public Player(Tv tv) {
        
            this.tv = tv;
        }
    
        @Override
        public void run() {
        
            for (int i = 0; i < 20; i++) {
        
                if (i % 2 == 0) {
        
                    this.tv.play("快乐大本营");
                } else {
        
                    this.tv.play("抖音：记录美好生活");
                }
            }
        }
    }

消费者：

class Watcher extends Thread {
        
    
        private Tv tv;
    
        public Watcher(Tv tv) {
        
            this.tv = tv;
        }
    
        @Override
        public void run() {
        
            for (int i = 0; i < 20; i++) {
        
                this.tv.watch();
            }
        }
    }

产品：

class Tv {
        
        // 节目
        private String voice;
        // 演员表演，观众等待 T
        // 观众观看，演员等待 F
        private boolean flag = true;
    
        // 表演
        public synchronized void play(String voice) {
        
            if (!flag) {
        
                try {
        
                    this.wait();
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }
            System.out.println("演员表演了" + voice);
            this.voice = voice;
            this.flag = !this.flag;
            // 通知观众观看
            this.notifyAll();
        }
    
        // 观看
        public synchronized String watch() {
        
            if (flag) {
        
                try {
        
                    this.wait();
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }
            System.out.println("观看了" + voice);
            // 通知演员表演
            this.notifyAll();
            this.flag = !this.flag;
            return voice;
        }
    }

测试：

public class TestPc2 {
        
    
        public static void main(String[] args) {
        
            Tv tv = new Tv();
            new Player(tv).start();
            new Watcher(tv).start();
        }
    }