线程：生产者与消费者模式

生产者与消费者：

1. /** 
2.  * 生产者每次生产10件商品，消费者每次消费1件商品 
3.  * 没有商品时生产者生产商品，有商品时消费者消费商品 
4.  */ 
5. class Producer extends Thread 
6. { 
7.     private Cangku ck; 
8.      
9.     public Producer(Cangku ck) 
10.     { 
11.         this.ck = ck; 
12.     } 
13.      
14.     public void run() 
15.     { 
16.         ck.createProduct(); 
17.     } 
18. } 
19.  
20. class Consumer extends Thread 
21. { 
22.     private Cangku ck; 
23.      
24.     public Consumer(Cangku ck) 
25.     { 
26.         this.ck = ck; 
27.     } 
28.      
29.     public void run() 
30.     { 
31.         ck.useProduct();// 消费商品 
32.     } 
33. } 
34.  
35. class Cangku//商品对象会变化，创建一个容器对象，锁住不变 
36. { 
37.     public synchronized void useProduct()//通过方法进行封装 
38.     { 
39.         for (int i = 0; i < 50; i++) 
40.         { 
41.             if (productSize() > 0) 
42.             { 
43.                 for (int j = 0; j < 10; j++) 
44.                 { 
45.                     Product p = removeProduct(0); 
46.                     System.out.println("消费了" + j + "个产品"); 
47.                 } 
48.             } 
49.             notify(); 
50.             try 
51.             { 
52.                 if (i != 49) 
53.                 { 
54.                     wait(); 
55.                 } 
56.             } 
57.             catch (InterruptedException e) 
58.             { 
59.                 e.printStackTrace(); 
60.             } 
61.              
62.         } 
63.          
64.     } 
65.      
66.     public synchronized void createProduct() 
67.     { 
68.         for (int i = 0; i < 50; i++) 
69.         { 
70.             if (productSize() == 0) 
71.             { 
72.                 for (int j = 0; j < 10; j++) 
73.                 { 
74.                     addProduct(new Product()); 
75.                 } 
76.                 System.out.println("生产了十个产品"); 
77.                 notify(); 
78.                 try 
79.                 { 
80.                     if (i != 49) 
81.                     { 
82.                         wait(); 
83.                     } 
84.                 } 
85.                 catch (InterruptedException e) 
86.                 { 
87.                     e.printStackTrace(); 
88.                 } 
89.             } 
90.         } 
91.          
92.     } 
93.      
94.     private LinkedList<Product> ppp = new LinkedList<Product>();//创建一个商品类型的容器 
95.      
96.     public int productSize() 
97.     { 
98.         return ppp.size(); 
99.     } 
100.      
101.     public void addProduct(Product p) 
102.     { 
103.         if (null != p) 
104.         { 
105.             ppp.add(p); 
106.         } 
107.     } 
108.      
109.     public Product removeProduct(int index) 
110.     { 
111.         return ppp.remove(index); 
112.     } 
113. } 
114.  
115. class Product 
116. { 
117.     String name = "玩具"; 
118. } 
119.  
120. public class Test 
121. { 
122.     public static void main(String[] args) 
123.     { 
124.         Cangku ck = new Cangku(); 
125.          
126.         Producer p = new Producer(ck); 
127.         Consumer c = new Consumer(ck); 
128.         p.start(); 
129.         c.start(); 
130.          
131.     } 
132. } 

重构经过：

1.

1. /** 
2.  * 加油一次20升，每次加完开车10公里 
3.  * 开车耗完油，没油时加油，有油时开车 
4.  * 双线程循环五十次 
5.  */ 
6. public class TwoThread 
7. { 
8.     public static void main(String[] args) 
9.     { 
10.         CarOilBox cob = new CarOilBox(); 
11.         Car c = new Car(cob); 
12.         Oil o = new Oil(cob); 
13.         c.start(); 
14.         o.start(); 
15.     } 
16.      
17. } 
18.  
19. class Car extends Thread 
20. { 
21.     private CarOilBox cob; 
22.      
23.     public Car(CarOilBox cob) 
24.     { 
25.         this.cob = cob; 
26.     } 
27.      
28.     @Override 
29.     public void run() 
30.     { 
31.         synchronized (cob) 
32.         { 
33.             for (int i = 0; i < 50; i++) 
34.             { 
35.                 if (cob.co != null) 
36.                 { 
37.                     for (int j = 0; j < 10; j++) 
38.                     { 
39.                         cob.co = null; 
40.                         System.out.println("第" + i + "次开车" + j + "公里"); 
41.                     } 
42.                 } 
43.                  
44.                 cob.notify(); 
45.                 if (i < 49) 
46.                 { 
47.                     try 
48.                     { 
49.                         cob.wait(); 
50.                     } 
51.                     catch (InterruptedException e) 
52.                     { 
53.                         e.printStackTrace(); 
54.                     } 
55.                 } 
56.             } 
57.         } 
58.     } 
59. } 
60.  
61. class Oil extends Thread 
62. { 
63.     private CarOilBox cob; 
64.      
65.     public Oil(CarOilBox cob) 
66.     { 
67.         this.cob = cob; 
68.     } 
69.      
70.     @Override 
71.     public void run() 
72.     { 
73.         synchronized (cob) 
74.         { 
75.             for (int i = 0; i < 50; i++) 
76.             { 
77.                 if (cob.co == null) 
78.                 { 
79.                     for (int j = 0; j < 20; j++) 
80.                     { 
81.                         cob.co = new CarOil(); 
82.                         System.out.println("第" + i + "次加油" + j + "升"); 
83.                     } 
84.                 } 
85.                  
86.                 cob.notify(); 
87.                 if (i < 49) 
88.                 { 
89.                     try 
90.                     { 
91.                         cob.wait(); 
92.                     } 
93.                     catch (InterruptedException e) 
94.                     { 
95.                         e.printStackTrace(); 
96.                     } 
97.                 } 
98.             } 
99.         } 
100.     } 
101. } 
102.  
103. class CarOil 
104. { 
105.      
106. } 
107.  
108. class CarOilBox 
109. { 
110.     CarOil co; 
111. } 

2.

1. public class CopyTwoThread 
2. { 
3.     public static void main(String[] args) 
4.     { 
5.         CarOilBox cob = new CarOilBox(); 
6.         Car c = new Car(cob); 
7.         Oil o = new Oil(cob); 
8.         c.start(); 
9.         o.start(); 
10.     } 
11.      
12. } 
13.  
14. class Car extends Thread 
15. { 
16.     private CarOilBox cob; 
17.      
18.     public Car(CarOilBox cob) 
19.     { 
20.         this.cob = cob; 
21.     } 
22.      
23.     @Override 
24.     public void run() 
25.     { 
26.         synchronized (cob) 
27.         { 
28.             for (int i = 0; i < 50; i++) 
29.             { 
30.                 if (cob.aco.size() != 0) 
31.                 { 
32.                     for (int j = 0; j < 10; j++) 
33.                     { 
34.                         CarOil co1 = cob.aco.remove(0); 
35.                         CarOil co2 = cob.aco.remove(0); 
36.                         System.out.println("第" + i + "次开车" + j + "公里"); 
37.                     } 
38.                 } 
39.                  
40.                 cob.notify(); 
41.                 if (i < 49) 
42.                 { 
43.                     try 
44.                     { 
45.                         cob.wait(); 
46.                     } 
47.                     catch (InterruptedException e) 
48.                     { 
49.                         e.printStackTrace(); 
50.                     } 
51.                 } 
52.             } 
53.         } 
54.     } 
55. } 
56.  
57. class Oil extends Thread 
58. { 
59.     private CarOilBox cob; 
60.      
61.     public Oil(CarOilBox cob) 
62.     { 
63.         this.cob = cob; 
64.     } 
65.      
66.     @Override 
67.     public void run() 
68.     { 
69.         synchronized (cob) 
70.         { 
71.             for (int i = 0; i < 50; i++) 
72.             { 
73.                 if (cob.aco.size() == 0) 
74.                 { 
75.                     for (int j = 0; j < 20; j++) 
76.                     { 
77.                         cob.aco.add(new CarOil()); 
78.                         System.out.println("第" + i + "次加油" + j + "升"); 
79.                     } 
80.                 } 
81.                  
82.                 cob.notify(); 
83.                 if (i < 49) 
84.                 { 
85.                     try 
86.                     { 
87.                         cob.wait(); 
88.                     } 
89.                     catch (InterruptedException e) 
90.                     { 
91.                         e.printStackTrace(); 
92.                     } 
93.                 } 
94.             } 
95.         } 
96.     } 
97. } 
98.  
99. class CarOil 
100. { 
101.      
102. } 
103.  
104. class CarOilBox 
105. { 
106.     CarOil co; 
107.     ArrayList<CarOil> aco =new ArrayList<CarOil>(); 
108. } 

3.

1. public class CopyTwoThread 
2. { 
3.     public static void main(String[] args) 
4.     { 
5.         CarOilBox cob = new CarOilBox(); 
6.         Car c = new Car(cob); 
7.         Oil o = new Oil(cob); 
8.         c.start(); 
9.         o.start(); 
10.     } 
11.      
12. } 
13.  
14. class Car extends Thread 
15. { 
16.     private CarOilBox cob; 
17.      
18.     public Car(CarOilBox cob) 
19.     { 
20.         this.cob = cob; 
21.     } 
22.      
23.     @Override 
24.     public void run() 
25.     { 
26.         synchronized (cob) 
27.         { 
28.             for (int i = 0; i < 50; i++) 
29.             { 
30.                 if (cob.arraySize() != 0) 
31.                 { 
32.                     for (int j = 0; j < 10; j++) 
33.                     { 
34.                         CarOil co1 = cob.arrayRemove(); 
35.                         CarOil co2 = cob.arrayRemove(); 
36.                         System.out.println("第" + i + "次开车" + j + "公里"); 
37.                     } 
38.                 } 
39.                  
40.                 cob.notify(); 
41.                 if (i < 49) 
42.                 { 
43.                     try 
44.                     { 
45.                         cob.wait(); 
46.                     } 
47.                     catch (InterruptedException e) 
48.                     { 
49.                         e.printStackTrace(); 
50.                     } 
51.                 } 
52.             } 
53.         } 
54.     } 
55. } 
56.  
57. class Oil extends Thread 
58. { 
59.     private CarOilBox cob; 
60.      
61.     public Oil(CarOilBox cob) 
62.     { 
63.         this.cob = cob; 
64.     } 
65.      
66.     @Override 
67.     public void run() 
68.     { 
69.         synchronized (cob) 
70.         { 
71.             for (int i = 0; i < 50; i++) 
72.             { 
73.                 if (cob.arraySize() == 0) 
74.                 { 
75.                     for (int j = 0; j < 20; j++) 
76.                     { 
77.                         cob.arrayAdd(); 
78.                         System.out.println("第" + i + "次加油" + j + "升"); 
79.                     } 
80.                 } 
81.                  
82.                 cob.notify(); 
83.                 if (i < 49) 
84.                 { 
85.                     try 
86.                     { 
87.                         cob.wait(); 
88.                     } 
89.                     catch (InterruptedException e) 
90.                     { 
91.                         e.printStackTrace(); 
92.                     } 
93.                 } 
94.             } 
95.         } 
96.     } 
97. } 
98.  
99. class CarOil 
100. { 
101.      
102. } 
103.  
104. class CarOilBox 
105. { 
106.     //CarOil co; 
107.     private ArrayList<CarOil> aco =new ArrayList<CarOil>(); 
108.      
109.     public int arraySize() 
110.     { 
111.         return aco.size(); 
112.     } 
113.      
114.     public CarOil arrayRemove() 
115.     { 
116.         return aco.remove(0); 
117.     } 
118.      
119.     public void arrayAdd() 
120.     { 
121.         aco.add(new CarOil()); 
122.     } 
123. } 

4.

1. public class CopyTwoThread 
2. { 
3.     public static void main(String[] args) 
4.     { 
5.         CarOilBox cob = new CarOilBox(); 
6.         Car c = new Car(cob); 
7.         Oil o = new Oil(cob); 
8.         c.start(); 
9.         o.start(); 
10.     } 
11.      
12. } 
13.  
14. class Car extends Thread 
15. { 
16.     private CarOilBox cob; 
17.      
18.     public Car(CarOilBox cob) 
19.     { 
20.         this.cob = cob; 
21.     } 
22.      
23.     @Override 
24.     public void run() 
25.     { 
26.         cob.driveCar(cob); 
27.     } 
28. } 
29.  
30. class Oil extends Thread 
31. { 
32.     private CarOilBox cob; 
33.      
34.     public Oil(CarOilBox cob) 
35.     { 
36.         this.cob = cob; 
37.     } 
38.      
39.     @Override 
40.     public void run() 
41.     { 
42.         cob.addOil(cob); 
43.     } 
44. } 
45.  
46. class CarOil 
47. { 
48.      
49. } 
50.  
51. class CarOilBox 
52. { 
53.     //CarOil co; 
54.     private ArrayList<CarOil> aco =new ArrayList<CarOil>(); 
55.      
56.     public int arraySize() 
57.     { 
58.         return aco.size(); 
59.     } 
60.      
61.     public CarOil arrayRemove() 
62.     { 
63.         return aco.remove(0); 
64.     } 
65.      
66.     public void arrayAdd() 
67.     { 
68.         aco.add(new CarOil()); 
69.     } 
70.     public synchronized void driveCar(CarOilBox cob) 
71.     { 
72.  
73.         for (int i = 0; i < 50; i++) 
74.         { 
75.             if (arraySize() != 0) 
76.             { 
77.                 for (int j = 0; j < 10; j++) 
78.                 { 
79.                     CarOil co1 = arrayRemove(); 
80.                     CarOil co2 = arrayRemove(); 
81.                     System.out.println("第" + i + "次开车" + j + "公里"); 
82.                 } 
83.             } 
84.              
85.             notify(); 
86.             if (i < 49) 
87.             { 
88.                 try 
89.                 { 
90.                     wait(); 
91.                 } 
92.                 catch (InterruptedException e) 
93.                 { 
94.                     e.printStackTrace(); 
95.                 } 
96.             } 
97.         } 
98.      
99.     } 
100.      
101.     public synchronized void addOil(CarOilBox cob) 
102.     { 
103.  
104.         for (int i = 0; i < 50; i++) 
105.         { 
106.             if (arraySize() == 0) 
107.             { 
108.                 for (int j = 0; j < 20; j++) 
109.                 { 
110.                     arrayAdd(); 
111.                     System.out.println("第" + i + "次加油" + j + "升"); 
112.                 } 
113.             } 
114.              
115.             notify(); 
116.             if (i < 49) 
117.             { 
118.                 try 
119.                 { 
120.                     wait(); 
121.                 } 
122.                 catch (InterruptedException e) 
123.                 { 
124.                     e.printStackTrace(); 
125.                 } 
126.             } 
127.         } 
128.        
129.     } 
130. }