生产者-消费者实例

1. package com.rx.thread.produce.consume;
3. public class Product {
4.     
5.     private String id;
7.     public String getId() {
8.         return id;
9.     }
11.     public void setId(String id) {
12.         this.id = id;
13.     }
15.     public Product(String id) {
16.         this.id = id;
17.     }
18.     
19.     public String toString() {
20.         return this.id;
21.     }
22.     
23.     public static void main(String[] args) {
24.         System.out.println(new Product("mrl"));
25.     }
26. }

1. package com.rx.thread.produce.consume;
3. public class Store {
4.     public Store() {    
5.     }
6.     
7.     /** 仓库中的产品 */
8.     private Product product = null;
9.     
10.     public Product getProduct() {
11.         return product;
12.     }
14.     public void setProduct(Product product) {
15.         this.product = product;
16.     }
18.     /** 显示当前仓库状态是否满 */
19.     private boolean empty = true;
21.     /***
22.      * 放置产品
23.      * @param product 放置的产品，可以抽象出来，放置任意物品
24.      */
25.     public void putProduct(Product product) {
26.         // 同步对象锁
27.         synchronized(this ) {
28.             while(!empty) {
29.                 try {
30.                     System.out.println(Thread.currentThread().getName() + " now is waiting for consuming up");
31.                     // 释放锁
32.                     this.wait(1000);
33.                 } catch (InterruptedException e) {
34.                     System.err.print(e.toString());
35.                     e.printStackTrace();
36.                 }
37.             }
38.             
39.             empty = false;
40.             this.product = product;
41.             System.out.println(Thread.currentThread().getName() + " put product : " + product.getId());
42.             
43.             //notify();
44.             this.notifyAll();
45.         }
46.     }
47.     
48.     /***
49.      * 取出产品
50.      * @return 取出的产品
51.      * @throws InterruptedException 
52.      */
53.     public synchronized Product takeOutProduct()  {
55.         while(empty){
56.             try {
57.                 System.out.println(Thread.currentThread().getName() + " now is waiting for product");
58.                 // 释放锁，并从该处返回
59.                 this.wait(1000);
60.                 // 获得权限(notify)后继续执行
61.                 System.out.println("waiting....");
62.             } catch (InterruptedException e) {
63.                 System.err.print(e.toString());
64.                 e.printStackTrace();
65.             }
66.         }
67.             
68.         System.out.println(Thread.currentThread().getName() + " take out product : "+ product.getId());
69.         empty = true;
70.         //notify();
71.         this.notifyAll();
72.         return this.product;
73.     }
75. }

 

1. package com.rx.thread.produce.consume;
3. public class Produce implements Runnable {
5.     /** 仓库 */
6.     Store store;
7.     
8.     /***
9.      * 设置产品放置的仓库
10.      * @param store 仓库
11.      */
12.     public Produce(Store store) {
13.         this.store = store;
14.     }
15.     
16.     public void run() {
17.         for(int i=0; i<4; i++) {
18.             store.putProduct(new Product(String.valueOf(i)));
19.             try {
20.                 Thread.sleep(1000);
21.             } catch (InterruptedException e) {
22.                 
23.                 e.printStackTrace();
24.             }
25.         }
26.     }
28. }

 

1. package com.rx.thread.produce.consume;
3. public class Consume implements Runnable {
4.     
5.     /** 仓库 */
6.     Store store;
7.     
8.     /***
9.      * 设置消费的仓库
10.      * @param store 仓库对象
11.      */
12.     public Consume(Store store) {
13.         this.store = store;
14.     }
15.     
16.     public void run() {
17.         while(true) {
18.             if(store.takeOutProduct().getId().endsWith("3")) {
19.                 break;
20.             }
21.         }
22.         System.out.println("end.");
23.     }
24. }

1. package com.rx.thread.produce.consume;
3. public class Test {
5.     /**
6.      * @param args
7.      */
8.     public static void main(String[] args) {
9.         
10.         Store store = new Store();
11.         
12.         (new Thread(new Produce(store))).start();
13.         //(new Thread(new Produce(store))).start();
14.         (new Thread(new Consume(store))).start();
15.         //(new Thread(new Consume(store))).start();
16.     }
18. }

 

Thread-0 put product : 0
Thread-1 take out product : 0
Thread-1 now is waiting for product
Thread-0 put product : 1
waiting....
Thread-1 take out product : 1
Thread-1 now is waiting for product
waiting....
Thread-1 now is waiting for product
Thread-0 put product : 2
waiting....
Thread-1 take out product : 2
Thread-1 now is waiting for product
waiting....
Thread-1 now is waiting for product
Thread-0 put product : 3
waiting....
Thread-1 take out product : 3
end.