概述：生产者消费者问题是线程之间通信的经典问题，下面的代码通过wait()和notify()方法实现生产者消费者问题，希望与大家交流。
消费者代码：

1. import java.util.ArrayList;
   
2. 
   
3. public class Consumer implements Runnable {
   
4.         // 定义一个资源变量
   
5.         private ArrayList<Object> resources;
   
6. 
   
7.         // 通过构造方法从外界获取资源对象
   
8.         public Consumer(ArrayList<Object> resources) {
   
9.                 super();
   
10.                 this.resources = resources;
    
11.         }
    
12. 
    
13.         @Override
    
14.         public void run() {
    
15.                 // 用共享资源当做线程同步锁
    
16.                 synchronized (resources) {
    
17. 
    
18.                         while (true) {
    
19.                                 // 如果有资源：集合中有元素
    
20.                                 if (resources.size() != 0) {
    
21.                                         // 消费资源
    
22.                                         Object element = resources.remove(resources.size() - 1);
    
23.                                         System.out.println(element + "has been consumed.");
    
24.                                         // 唤醒生产者线程
    
25.                                         resources.notify();
    
26.                                 } else {
    
27.                                         // 没有可消费的资源，等待生产者生产
    
28.                                         try {
    
29.                                                 resources.wait();
    
30.                                         } catch (InterruptedException e) {
    
31.                                                 e.printStackTrace();
    
32.                                         }
    
33.                                 }
    
34.                         }
    
35.                 }
    
36.         }
    
37. 
    
38. }

复制代码

生产者代码

1. import java.util.ArrayList;
   
2. 
   
3. public class Producer implements Runnable {
   
4.         // 定义一个资源变量
   
5.         private ArrayList<Object> resources;
   
6. 
   
7.         // 通过构造方法从外界获取资源对象
   
8.         public Producer(ArrayList<Object> resources) {
   
9.                 super();
   
10.                 this.resources = resources;
    
11.         }
    
12. 
    
13.         @Override
    
14.         public void run() {
    
15. 
    
16.                 while (true) {
    
17.                         // 用共享资源当做线程同步锁
    
18.                         synchronized (resources) {
    
19.                                 // 如果没有资源：集合中没有元素
    
20.                                 if (resources.size() == 0) {
    
21.                                         // 生产资源：向集合中添加元素
    
22.                                         resources.add("element-" + resources.size());
    
23.                                         // 打印提示：新元素已经添加
    
24.                                         System.out.println("New element has been produced.");
    
25.                                         // 唤醒消费者线程消费已经生产的资源
    
26.                                         resources.notify();
    
27.                                 } else {
    
28.                                         // 如果有资源，等待消费者消费
    
29.                                         try {
    
30.                                                 resources.wait();
    
31.                                         } catch (InterruptedException e1) {
    
32.                                                 e1.printStackTrace();
    
33.                                         }
    
34.                                 }
    
35.                         }
    
36.                 }
    
37.         }
    
38. }
    

复制代码

测试类代码

1. import java.util.ArrayList;
   
2. 
   
3. public class ThreadDemo {
   
4.         public static void main(String[] args) {
   
5.                 // 创建资源对象
   
6.                 ArrayList<Object> resources = new ArrayList<Object>();
   
7.                 // 创建生产者消费者对象
   
8.                 Producer p = new Producer(resources);
   
9.                 Consumer c = new Consumer(resources);
   
10.                 // 创建生产者消费者线程
    
11.                 Thread produce = new Thread(p, "producer");
    
12.                 Thread consume = new Thread(c, "consumer");
    
13.                 // 启动线程
    
14.                 produce.start();
    
15.                 consume.start();
    
16.         }
    
17. }
    

复制代码

概述：生产者消费者问题是线程之间通信的经典问题，下面的代码通过wait()和notify()方法实现生产者消费者问题，希望与大家交流。
消费者代码：

1. import java.util.ArrayList;
   
2. 
   
3. public class Consumer implements Runnable {
   
4.         // 定义一个资源变量
   
5.         private ArrayList<Object> resources;
   
6. 
   
7.         // 通过构造方法从外界获取资源对象
   
8.         public Consumer(ArrayList<Object> resources) {
   
9.                 super();
   
10.                 this.resources = resources;
    
11.         }
    
12. 
    
13.         @Override
    
14.         public void run() {
    
15.                 // 用共享资源当做线程同步锁
    
16.                 synchronized (resources) {
    
17. 
    
18.                         while (true) {
    
19.                                 // 如果有资源：集合中有元素
    
20.                                 if (resources.size() != 0) {
    
21.                                         // 消费资源
    
22.                                         Object element = resources.remove(resources.size() - 1);
    
23.                                         System.out.println(element + "has been consumed.");
    
24.                                         // 唤醒生产者线程
    
25.                                         resources.notify();
    
26.                                 } else {
    
27.                                         // 没有可消费的资源，等待生产者生产
    
28.                                         try {
    
29.                                                 resources.wait();
    
30.                                         } catch (InterruptedException e) {
    
31.                                                 e.printStackTrace();
    
32.                                         }
    
33.                                 }
    
34.                         }
    
35.                 }
    
36.         }
    
37. 
    
38. }

复制代码

生产者代码

1. import java.util.ArrayList;
   
2. 
   
3. public class Producer implements Runnable {
   
4.         // 定义一个资源变量
   
5.         private ArrayList<Object> resources;
   
6. 
   
7.         // 通过构造方法从外界获取资源对象
   
8.         public Producer(ArrayList<Object> resources) {
   
9.                 super();
   
10.                 this.resources = resources;
    
11.         }
    
12. 
    
13.         @Override
    
14.         public void run() {
    
15. 
    
16.                 while (true) {
    
17.                         // 用共享资源当做线程同步锁
    
18.                         synchronized (resources) {
    
19.                                 // 如果没有资源：集合中没有元素
    
20.                                 if (resources.size() == 0) {
    
21.                                         // 生产资源：向集合中添加元素
    
22.                                         resources.add("element-" + resources.size());
    
23.                                         // 打印提示：新元素已经添加
    
24.                                         System.out.println("New element has been produced.");
    
25.                                         // 唤醒消费者线程消费已经生产的资源
    
26.                                         resources.notify();
    
27.                                 } else {
    
28.                                         // 如果有资源，等待消费者消费
    
29.                                         try {
    
30.                                                 resources.wait();
    
31.                                         } catch (InterruptedException e1) {
    
32.                                                 e1.printStackTrace();
    
33.                                         }
    
34.                                 }
    
35.                         }
    
36.                 }
    
37.         }
    
38. }
    

复制代码

测试类代码

1. import java.util.ArrayList;
   
2. 
   
3. public class ThreadDemo {
   
4.         public static void main(String[] args) {
   
5.                 // 创建资源对象
   
6.                 ArrayList<Object> resources = new ArrayList<Object>();
   
7.                 // 创建生产者消费者对象
   
8.                 Producer p = new Producer(resources);
   
9.                 Consumer c = new Consumer(resources);
   
10.                 // 创建生产者消费者线程
    
11.                 Thread produce = new Thread(p, "producer");
    
12.                 Thread consume = new Thread(c, "consumer");
    
13.                 // 启动线程
    
14.                 produce.start();
    
15.                 consume.start();
    
16.         }
    
17. }
    

复制代码