这个是我根据教程自己改写的一个程序，我想让这个程序自动停止，但试了很多方法都没实现，哪位高手看看是什么原因？？？谢谢！！！！

1. 
   
2. 
   
3. import java.util.concurrent.locks.*;
   
4. 
   
5. class Produce{
   
6.         int num = 50;
   
7.         private String name;
   
8.         private int count = 0;
   
9.         boolean flag = false;
   
10.         private final Lock lock = new ReentrantLock();
    
11.         final Condition pro = lock.newCondition();
    
12.         final Condition con = lock.newCondition();
    
13.         public String getName() {
    
14.                 return name;
    
15.         }
    
16.         public void setName(String name) {
    
17.                 this.name = name;
    
18.         }
    
19.         public int getCount() {
    
20.                 return count;
    
21.         }
    
22.         public void setCount(int count) {
    
23.                 this.count = count;
    
24.         }
    
25.         public void putIn() throws InterruptedException{
    
26.                 while(getCount()<num){
    
27.                         lock.lock();
    
28.                         try {
    
29.                                 Thread.sleep(50);
    
30.                         }
    
31.                         catch (InterruptedException e1) {
    
32.                                 // TODO Auto-generated catch block
    
33.                                 e1.printStackTrace();
    
34.                         }
    
35.                         try{
    
36.                                 while(flag){
    
37.                                         pro.await();
    
38.                                 }
    
39.                                 if(getCount()<num){
    
40.                                         this.setName("生产者");
    
41.                                         count++;
    
42.                                         System.out.println(Thread.currentThread().getName()+"---"+name+"---"+count);
    
43.                                         flag = true;
    
44.                                         con.signal();
    
45.                                 }
    
46.                         }
    
47.                         finally{
    
48.                                 lock.unlock();
    
49.                         }
    
50.                 }
    
51.         }
    
52.         public void putOut() throws InterruptedException{
    
53.                 while(getCount()<=num){
    
54.                         lock.lock();
    
55.                         try {
    
56.                                 Thread.sleep(50);
    
57.                         }
    
58.                         catch (InterruptedException e1) {
    
59.                                 // TODO Auto-generated catch block
    
60.                                 e1.printStackTrace();
    
61.                         }
    
62.                         try{
    
63.                                 while(!flag){
    
64.                                         con.await();
    
65.                                 }
    
66.                                 if(getCount()<num){
    
67.                                         this.setName("消费者");
    
68.                                         System.out.println(Thread.currentThread().getName()+"----"+name+"----"+count);
    
69.                                         //count++;
    
70.                                         flag = false;
    
71.                                         pro.signal();
    
72.                                 }
    
73.                                 //在这里我改变了条件，为什么还是不能自动停止呢？？？
    
74.                                 else if(getCount()==num){
    
75.                                         this.setName("消费者");
    
76.                                         System.out.println(Thread.currentThread().getName()+"----"+name+"----"+count);
    
77.                                         count++;
    
78.                                 }
    
79.                         }
    
80.                         finally{
    
81.                                 lock.unlock();
    
82.                         }
    
83.                 }
    
84.         }
    
85. }
    
86. 
    
87. class Producer implements Runnable{
    
88.         private Produce p;
    
89.         Producer(Produce p){
    
90.                 this.p = p;
    
91.         }
    
92.         public void run(){
    
93.                 try {
    
94.                         p.putIn();
    
95.                 } catch (InterruptedException e) {
    
96.                         // TODO Auto-generated catch block
    
97.                         e.printStackTrace();
    
98.                 }
    
99.         }
    
100. }
     
101. 
     
102. class Consumer implements Runnable{
     
103.         private Produce p;
     
104.         Consumer(Produce p){
     
105.                 this.p = p;
     
106.         }
     
107.         public void run(){
     
108.                 try {
     
109.                         p.putOut();
     
110.                 } catch (InterruptedException e) {
     
111.                         // TODO Auto-generated catch block
     
112.                         e.printStackTrace();
     
113.                 }
     
114.         }
     
115. }
     
116. 
     
117. public class LockTest {
     
118. 
     
119.         /**
     
120.          * @param args
     
121.          */
     
122.         public static void main(String[] args) {
     
123.                 // TODO Auto-generated method stub
     
124.                 Produce p = new Produce();
     
125.                 new Thread(new Producer(p)).start();
     
126.                 new Thread(new Producer(p)).start();
     
127.                 new Thread(new Consumer(p)).start();
     
128.                 new Thread(new Consumer(p)).start();
     
129.         }
     
130. 
     
131. }
     

复制代码

import java.util.concurrent.locks.*;

class Produce{
        int num = 50;
        private String name;
        private int count = 0;
        boolean flag = false;
        private final Lock lock = new ReentrantLock();
        final Condition pro = lock.newCondition();
        final Condition con = lock.newCondition();
        public String getName() {
                return name;
        }
        public void setName(String name) {
                this.name = name;
        }
        public int getCount() {
                return count;
        }
        public void setCount(int count) {
                this.count = count;
        }
        public void putIn() throws InterruptedException{
                while(getCount()<num){
                        lock.lock();
                        try {
                                Thread.sleep(50);
                        }
                        catch (InterruptedException e1) {
                                // TODO Auto-generated catch block
                                e1.printStackTrace();
                        }
                        try{
                                while(flag){
                                        pro.await();
                                }
                                if(getCount()<num){
                                        this.setName("生产者");
                                        count++;
                                        System.out.println(Thread.currentThread().getName()+"---"+name+"---"+count);
                                        flag = true;
                                        con.signal();
                                }
                        }
                        finally{
                                lock.unlock();
                        }
                }
        }
        public void putOut() throws InterruptedException{
                while(getCount()<=num){
                        lock.lock();
                        try {
                                Thread.sleep(50);
                        }
                        catch (InterruptedException e1) {
                                // TODO Auto-generated catch block
                                e1.printStackTrace();
                        }
                        try{
                                while(!flag){
                                        con.await();
                                }
                                if(getCount()<num){
                                        this.setName("消费者");
                                        System.out.println(Thread.currentThread().getName()+"----"+name+"----"+count);
                                        //count++;
                                        flag = false;
                                        pro.signal();
                                }
                                //在这里我改变了条件，为什么还是不能自动停止呢？？？
                                else if(getCount()==num){
                                        this.setName("消费者");
                                        System.out.println(Thread.currentThread().getName()+"----"+name+"----"+count);
                                        count++;
                                }
                        }
                        finally{
                                lock.unlock();
                        }
                }
        }
}

class Producer implements Runnable{
        private Produce p;
        Producer(Produce p){
                this.p = p;
        }
        public void run(){
                try {
                        p.putIn();
                } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
        }
}

class Consumer implements Runnable{
        private Produce p;
        Consumer(Produce p){
                this.p = p;
        }
        public void run(){
                try {
                        p.putOut();
                } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
        }
}

public class LockTest {

        /**
         * @param args
         */
        public static void main(String[] args) {
                // TODO Auto-generated method stub
                Produce p = new Produce();
                new Thread(new Producer(p)).start();
                new Thread(new Producer(p)).start();
                new Thread(new Consumer(p)).start();
                new Thread(new Consumer(p)).start();
        }

}