1. import java.util.ArrayList;
    2. import java.util.List;
    3. import java.util.UUID;
    5. /**
    6.  * @author zhenlong
    7.  * @version $Id: PC.java, v 0.1 2020年05月11日 12:48 AM zhenlong Exp $
    8.  */
    9. public class PC {
    11.     public static void main(String[] args) {
    12.         Resource resource = new Resource(10);
    13.         //生产者线程
    14.         ProducerThread p1 = new ProducerThread(resource, "生产者1号");
    15.         ProducerThread p2 = new ProducerThread(resource, "生产者2号");
    16.         ProducerThread p3 = new ProducerThread(resource, "生产者3号");
    17.         //消费者线程
    18.         ConsumerThread c1 = new ConsumerThread(resource, "消费者1号");
    19.         //ConsumerThread c2 = new ConsumerThread(resource);
    20.         //ConsumerThread c3 = new ConsumerThread(resource);
    22.         p1.start();
    23.         p2.start();
    24.         p3.start();
    25.         c1.start();
    26.         //c2.start();
    27.         //c3.start();
    28.     }
    30.     // 公共资源类
    31.     static class Resource {
    32.         // 锁
    33.         private final Object       lock;
    34.         // 当前数量
    35.         private       List<String> taskList;
    36.         // 任务上限
    37.         private       int          capacity;
    39.         public Resource(int capacity) {
    40.             this.capacity = capacity;
    41.             this.taskList = new ArrayList<>();
    42.             this.lock = new Object();
    43.         }
    45.         public void consume() throws Exception {
    46.             synchronized (lock) {
    47.                 if (taskList.size() > 0) {
    48.                     String task = taskList.remove(0);
    49.                     System.out.println(Thread.currentThread().getName() +
    50.                             "处理任务:" + task + "完成,当前池中任务数量:" + taskList.size());
    51.                     //通知生产者生产资源
    52.                     lock.notifyAll();
    53.                 } else {
    54.                     //如果没有资源，则消费者进入等待状态
    55.                     System.out.println(Thread.currentThread().getName() + "线程进入等待");
    56.                     lock.wait();
    57.                 }
    58.             }
    59.         }
    61.         /**
    62.          * 向资源池中添加资源
    63.          */
    64.         public void produce() throws Exception {
    65.             synchronized (lock) {
    66.                 if (taskList.size() < capacity) {
    67.                     taskList.add(UUID.randomUUID().toString());
    68.                     System.out.println(Thread.currentThread().getName()
    69.                             + "生成任务,当前池中任务数量:" + taskList.size());
    70.                     //通知等待的消费者
    71.                     lock.notifyAll();
    72.                 } else {
    73.                     // 队列已满计入等到
    74.                     System.out.println(Thread.currentThread().getName() + "线程进入等待");
    75.                     lock.wait();
    76.                 }
    77.             }
    78.         }
    79.     }
    81.     // 消费者线程
    82.     static class ConsumerThread extends Thread {
    84.         private Resource resource;
    86.         public ConsumerThread(Resource resource, String name) {
    87.             this.resource = resource;
    88.             super.setName(name);
    89.         }
    91.         @Override
    92.         public void run() {
    93.             while (true) {
    94.                 try {
    95.                     Thread.sleep((long) (Math.random() * 1000));
    96.                     resource.consume();
    97.                 } catch (Exception e) {
    98.                     e.printStackTrace();
    99.                 }
    100.             }
    101.         }
    102.     }
    104.     // 生产者线程
    105.     static class ProducerThread extends Thread {
    106.         private Resource resource;
    108.         public ProducerThread(Resource resource, String name) {
    109.             this.resource = resource;
    110.             super.setName(name);
    111.         }
    113.         @Override
    114.         public void run() {
    115.             //不断地生产资源
    116.             while (true) {
    117.                 try {
    118.                     Thread.sleep((long) (Math.random() * 1000));
    119.                     resource.produce();
    120.                 } catch (Exception e) {
    121.                     e.printStackTrace();
    122.                 }
    123.             }
    124.         }
    125.     }
    126. }