wait notify 生产者消费者模型

生产者

 1 import java.util.List;
 2 import java.util.Random;
 3 
 4 
 5 public class Producer {
 6     private Object lock;
 7 
 8     private List<String> products;
 9 
10     public Producer(Object lock, List<String> products) {
11         this.lock = lock;
12         this.products = products;
13     }
14 
15     public void produce() throws InterruptedException {
16         int i = 0;
17         while (true) {
18             String name = "producer" + Thread.currentThread().getName();
19             synchronized (lock) {
20                 if (products.size() > 10) {
21                     System.out.println(name + " stop produce");
22                     lock.wait();
23                 }
24                 String prod = "test" + ++i;
25                 System.out.println("start produce, product:[" + prod + "]");
26                 products.add(prod);
27                 lock.notify();
28                 Thread.sleep(new Random().nextInt(1500));
29             }
30         }
31     }
32 }

消费者

 1 import java.util.List;
 2 import java.util.Random;
 3 
 4 
 5 public class Consumer {
 6     private Object lock;
 7     private List<String> products;
 8 
 9     public Consumer(Object lock, List<String> products) {
10         this.lock = lock;
11         this.products = products;
12     }
13 
14     public void consume() throws InterruptedException {
15         String name = "Consumer:" + Thread.currentThread().getName();
16         while (true) {
17             synchronized (lock) {
18                 if (products.isEmpty()) {
19                     System.out.println(name + " is waiting for consume");
20                     lock.wait();
21                 }
22 
23                 String product = products.remove(0);
24                 System.out.println(name + " consome :[" + product + "]");
25                 lock.notify();
26             }
27             Thread.sleep(new Random().nextInt(2000));
28         }
29     }
30 }

测试类

 1 import java.util.ArrayList;
 2 import java.util.List;
 3 
 4 
 5 public class WaitNotifyTest {
 6     public static void main(String[] args) throws Exception {
 7         Object lock = new Object();
 8         List<String> list = new ArrayList<String>();
 9         final Producer producer = new Producer(lock, list);
10         final Consumer consumer = new Consumer(lock, list);
11         Thread p1 = new Thread() {
12             @Override
13             public void run() {
14                 try {
15                     producer.produce();
16                 } catch (InterruptedException e) {
17                     e.printStackTrace();
18                 }
19             }
20         };
21         p1.start();
22 
23         Thread c1 = new Thread() {
24             @Override
25             public void run() {
26                 try {
27                     consumer.consume();
28                 } catch (InterruptedException e) {
29                     e.printStackTrace();
30                 }
31             }
32         };
33         c1.start();
34 
35         Thread c2 = new Thread() {
36             @Override
37             public void run() {
38                 try {
39                     consumer.consume();
40                 } catch (InterruptedException e) {
41                     e.printStackTrace();
42                 }
43             }
44         };
45         c2.start();
46 
47     }
48 }