1. import java.util.concurrent.locks.Condition;
   
2. import java.util.concurrent.locks.Lock;
   
3. import java.util.concurrent.locks.ReentrantLock;
   
4. public class Demo28 {
   
5. 
   
6.         public static void main(String[] args) {
   
7.                 Ticket t = new Ticket(100);
   
8.                 for(int i=0; i<5; i++){
   
9.                         new Thread(t).start();
   
10.                         try{
    
11.                                 Thread.sleep(200);
    
12.                         }catch(InterruptedException e){
    
13.                                 e.printStackTrace();
    
14.                         }
    
15.                 }
    
16.         }
    
17. }
    
18. class Ticket implements Runnable{
    
19.         private int num;
    
20.         private String id;
    
21.         boolean flag = true;
    
22.         Lock lock = new ReentrantLock();
    
23.         Condition con = lock.newCondition();
    
24.         public Ticket(int num){
    
25.                 this.num = num;
    
26.         }
    
27.         public int getNum(){
    
28.                 return num;
    
29.         }
    
30.         public void run(){
    
31.                 lock.lock();
    
32.                 if(flag){
    
33.                         while(true){
    
34.                                 synchronized(this){
    
35.                                         if(num > 0){
    
36.                                                 try{
    
37.                                                         Thread.sleep(200);
    
38.                                                         System.out.println(Thread.currentThread().getName()+"----"+num--);
    
39.                                                 }catch(InterruptedException e){
    
40.                                                         e.printStackTrace();
    
41.                                                 }
    
42.                                                 lock.unlock();
    
43.                                                 this.notifyAll();
    
44.                                                 break;
    
45.                                         }
    
46.                                         else{
    
47.                                                 lock.unlock();
    
48.                                                 break;
    
49.                                         }
    
50.                                 }
    
51.                         }
    
52.                 }
    
53.         }
    
54. }

复制代码

求大神帮我看看这个售票问题的程序错在哪里，程序执行打印出 Thread-0----100 之后就停在了那里。。。

肚小糖 发表于 2015-9-16 08:42
这样改了以后只有Thread-0在执行，这种情况怎么办？

把第12行代码   t.flag = false;  注释掉就行了 ，我记得我回答过这个问题啊

一分一分的攒，天啊

你这写的什么鬼啊，wait 和notify是等待唤醒机制，属于线程通信问题。
首先这题，都是处理卖票的问题，这五个线程的操作是一样的都是为了减少资源，用不到线程通信；生产者消费者问题这样的线程处理资源方式不相同（一个是增加，一个是减少）这样才需要线程间通信，用到等待唤醒机制。
而且你还用了1.5新特性lock锁，那么你定义了condition为啥没用con.await和con.signal ，还有wait和sleep用法是不一样的，特别是涉及到锁的时候。

夸克 发表于 2015-9-15 16:59
你这写的什么鬼啊，wait 和notify是等待唤醒机制，属于线程通信问题。
首先这题，都是处理卖票的 ...

1. public class Demo28 {
   
2. 
   
3.         public static void main(String[] args) {
   
4.                 Ticket t = new Ticket(100);
   
5.                 for(int i=0; i<5; i++){
   
6.                         new Thread(t).start();
   
7.                         try{
   
8.                                 Thread.sleep(200);
   
9.                         }catch(InterruptedException e){
   
10.                                 e.printStackTrace();
    
11.                         }
    
12.                         t.flag = false;
    
13.                 }
    
14.         }
    
15. }
    
16. class Ticket implements Runnable{
    
17.         private int num;
    
18.         boolean flag = true;
    
19.         public Ticket(int num){
    
20.                 this.num = num;
    
21.         }
    
22.         public int getNum(){
    
23.                 return num;
    
24.         }
    
25.         public void run(){
    
26.                 if(flag){
    
27.                         while(true){
    
28.                                 synchronized(this){
    
29.                                         if(num > 0){
    
30.                                                 try{
    
31.                                                         Thread.sleep(200);
    
32.                                                 }catch(InterruptedException e){
    
33.                                                         e.printStackTrace();
    
34.                                                 }
    
35.                                                 System.out.println(Thread.currentThread().getName()+"----"+num--);
    
36.                                         }
    
37.                                         else{
    
38.                                                 break;
    
39.                                         }
    
40.                                 }
    
41.                         }
    
42.                 }
    
43.         }
    
44. }

复制代码

这样改了以后只有Thread-0在执行，这种情况怎么办？