学习和理解JAVA线程同步--生产者与消费者例子

太过爱你忘了你带给我的痛 2022-09-17 10:20 80阅读 0赞

### [学习和理解JAVA线程同步--生产者与消费者例子][JAVA_--] ###

JAVA线程同步通常需要使用sychronized对临界资源进行加锁，所谓的临界资源就是指这些线程共同使用的资源。

sychronized通常是放在方法名前，这是表示这个方法是同步的，实际上是对this加锁。

或者放在一个对象前，对某个共同使用的对象加锁。

生产者和消费者的例子是非常经典的，这里需要定义一个池子，用于往里放入产品。定义生产者不断生产产品，当池子不满的情况下可以继续放，满了则等待。

消费者一直从池子取，池子空则等待。

我们使用实现runnable来实现生产者和消费者。

写一个同步栈作为池子，对push和pop方法进行同步。  
代码如下：

**\[java\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  **class** SycnStack\{  
2.      **private** Integer index=0;  
3.      **private** **char**\[\] data;  
4.        
5.      **public** SycnStack(**int** num)\{  
6.          data = **new** **char**\[num\];  
7.      \}  
8.        
9.      **public** **void** push(**char** c)\{  
10.         **synchronized** (**this**) \{ //对index加锁为何不行？？？必须this  
11.             **while**(index==data.length-1)   
12.             \{  
13.                 System.out.println("池子已经满，不能放入了！"\+Thread.currentThread().toString());  
14.                 **try** \{  
15.                     **this**.wait();  
16.                 \} **catch** (InterruptedException e) \{  
17.                     e.printStackTrace();  
18.                 \}  
19.             \}  
20.             **this**.notify();//获取锁  
21.                 data\[index\]=c;  
22.                 System.out.println("放入"\+c+" "\+Thread.currentThread().toString());  
23.                 index++;  
24.         \}  
25.     \}  
26.     **public** Character pop()\{  
27.         **synchronized** (**this**) \{  
28.             **while**(index==0)\{  
29.                 System.out.println("池子已经空了，取不了了！"\+Thread.currentThread().toString());  
30.                 **try** \{  
31.                     **this**.wait();  
32.                 \} **catch** (InterruptedException e) \{  
33.                     e.printStackTrace();  
34.                 \}  
35.             \}  
36.             **this**.notify();  
37.                 index--;  
38.                 **char** c = data\[index\];  
39.                 System.out.println("取出"\+c+" "\+Thread.currentThread().toString());  
40.                 **return** c;  
41.         \}  
42.     \}

然后写生产者和消费者，其run方法就是不断的生产产品放入池子或取出产品：

**\[java\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  **class** Producer **implements** Runnable\{  
2.      **private** SycnStack stack;  
3.      **public** Producer(SycnStack stack)\{  
4.          **this**.stack = stack;  
5.      \}  
6.      @Override  
7.      **public** **void** run() \{  
8.          **int** i=10;  
9.          **while**(i-->0)\{  
10.             stack.push( (**char**)(26\*Math.random()+'A'));  
11.             Thread.yield();  
12.         \}  
13.     \}  
14. \}  
15. **class** Consumer **implements** Runnable\{  
16.     **private** SycnStack stack;  
17.     **public** Consumer(SycnStack stack)\{  
18.         **this**.stack = stack;  
19.     \}  
20.     @Override  
21.     **public** **void** run() \{  
22.         **int** i=10;  
23.         **while**(i-->0)\{  
24.             stack.pop();  
25.             Thread.yield();  
26.         \}  
27.     \}  
28. \}

main方法如下，创建一个栈用于放产品，然后创建生产者和消费者都用这个产品栈，并启动：

**\[java\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  **public** **class** ProductorConsumer \{  
2.    
3.      **public** **static** **void** main(String\[\] args)\{  
4.            
5.          SycnStack s = **new** SycnStack(5);  
6.          **new** Thread(**new** Producer(s)).start();  
7.          **new** Thread(**new** Consumer(s)).start();  
8.      \}  
9.        
10. \}

结果如下：

**\[plain\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  放入G Thread\[Thread-0,5,main\]  
2.  放入L Thread\[Thread-0,5,main\]  
3.  放入D Thread\[Thread-0,5,main\]  
4.  放入K Thread\[Thread-0,5,main\]  
5.  池子已经满，不能放入了！Thread\[Thread-0,5,main\]  
6.  取出K Thread\[Thread-1,5,main\]  
7.  放入P Thread\[Thread-0,5,main\]  
8.  池子已经满，不能放入了！Thread\[Thread-0,5,main\]  
9.  取出P Thread\[Thread-1,5,main\]  
10. 放入E Thread\[Thread-0,5,main\]  
11. 池子已经满，不能放入了！Thread\[Thread-0,5,main\]  
12. 取出E Thread\[Thread-1,5,main\]  
13. 放入M Thread\[Thread-0,5,main\]  
14. 池子已经满，不能放入了！Thread\[Thread-0,5,main\]  
15. 取出M Thread\[Thread-1,5,main\]  
16. 放入P Thread\[Thread-0,5,main\]  
17. 池子已经满，不能放入了！Thread\[Thread-0,5,main\]  
18. 取出P Thread\[Thread-1,5,main\]  
19. 放入Q Thread\[Thread-0,5,main\]  
20. 池子已经满，不能放入了！Thread\[Thread-0,5,main\]  
21. 取出Q Thread\[Thread-1,5,main\]  
22. 放入L Thread\[Thread-0,5,main\]  
23. 取出L Thread\[Thread-1,5,main\]  
24. 取出D Thread\[Thread-1,5,main\]  
25. 取出L Thread\[Thread-1,5,main\]  
26. 取出G Thread\[Thread-1,5,main\]

再看同步栈的代码第十行，是对this加锁，指的就是对当前这个栈加锁。

之前我测试使用对index加锁，发现是会报错的，我想可能是因为临界资源不仅是index,还有data,如果只对index加锁，当一个线程在用栈的时候，另一个线程仍然能够使用这个栈，就会造成index的混乱之后就报错了。

如果谁有更详细的解释也可以告诉我。

[JAVA_--]: http://blog.csdn.net/happyteafriends/article/details/8153048
[view plain]: http://blog.csdn.net/happyteafriends/article/details/8153048#