1. public class ProducerConsumer {
   
2. 
   
3.         public static void main(String[] args) {
   
4.                 Resouse account = new Resouse() ;
   
5.                 Producer producer = new Producer(account) ;
   
6.                 Consumer consumer = new Consumer(account);
   
7.                
   
8.                 Thread t1 = new Thread(producer);
   
9.                 Thread t2 = new Thread(producer);
   
10.                 Thread t3 = new Thread(consumer);
    
11.                 Thread t4 = new Thread(consumer);
    
12.                 t1.start();
    
13.                 t2.start();
    
14.                 t3.start();
    
15.                 t4.start();
    
16. 
    
17.         }
    
18. }
    
19. 
    
20. class Resouse {
    
21.         int sum = 0 ;
    
22.         Boolean flag = false;
    
23.         synchronized void save(){
    
24.                 if(flag){
    
25.                         try {
    
26.                                 wait();
    
27.                         } catch (InterruptedException e) {
    
28.                                 // TODO Auto-generated catch block
    
29.                                 e.printStackTrace();
    
30.                         }
    
31.                 }else {
    
32.                         notifyAll();
    
33.                         flag = true ;
    
34.                         sum++ ;
    
35.                         System.out.println("producer"+sum);
    
36.                 }
    
37.         }
    
38.        
    
39.         synchronized void out(){
    
40.                 if(!flag){
    
41.                         try {
    
42.                                 wait();
    
43.                         } catch (InterruptedException e) {
    
44.                                 // TODO Auto-generated catch block
    
45.                                 e.printStackTrace();
    
46.                         }
    
47.                 }else {
    
48.                         notifyAll();
    
49.                         flag = false ;
    
50.                         System.out.println("consumer<<<"+sum);
    
51.                 }
    
52.         }
    
53. }
    
54. 
    
55. class Producer implements Runnable{
    
56.         Resouse account ;
    
57.         public Producer(Resouse account ){
    
58.                 this.account = account ;
    
59.         }
    
60.         public void run(){
    
61.                 for(int i=0;i<100;i++){
    
62.                         account.save();
    
63.                 }
    
64.         }
    
65. }
    
66. 
    
67. class Consumer implements Runnable{
    
68.         Resouse account ;
    
69.         public Consumer(Resouse account ){
    
70.                 this.account = account ;
    
71.         }
    
72.         public void run(){
    
73.                 for(int i=0;i<100;i++){
    
74.                         account.out();
    
75.                 }
    
76.         }
    
77. }

复制代码

大部分时候结果小于100，有时还大于100.

没看懂，为啥要锁两个函数，用lock就好了吗。