1. public class Demo implements Runnable {
   
2.         private int ticket = 100;
   
3.         Object obj = new Object();
   
4. 
   
5.         @Override
   
6.         public void run() {
   
7.                 synchronized (obj) {
   
8.                         
   
9.                
   
10.                 do {
    
11.                         try {
    
12.                                 Thread.sleep(10);
    
13.                         } catch (InterruptedException e) {
    
14.                                 // TODO Auto-generated catch block
    
15.                                 e.printStackTrace();
    
16.                         }
    
17.                         System.out.println(Thread.currentThread().getName() + "***"
    
18.                                         + ticket--);
    
19.                 } while (ticket > 0);}
    
20.         }
    
21. 
    
22.         public static void main(String[] args) {
    
23.                 Demo d = new Demo();
    
24.                 Thread t1 = new Thread(d);
    
25.                 Thread t2 = new Thread(d);
    
26.                 Thread t3 = new Thread(d);
    
27.                 Thread t4 = new Thread(d);
    
28. 
    
29.                 t1.start();
    
30.                 t2.start();
    
31.                 t3.start();
    
32.                 t4.start();
    
33. 
    
34.         }
    
35. 
    
36. }

复制代码

上边这段代码和毕老师的差不多，但是为什么还是会出现ticket<0的情况？

package demo1;
public class Demo implements Runnable {
        private int ticket = 100;
        Object obj = new Object();
        @Override
        public void run() {
            synchronized (obj) {                    
             do {
                     try {
                             Thread.sleep(10);
                     } catch (InterruptedException e) {
                             // TODO Auto-generated catch block
                             e.printStackTrace();
                     }
                     System.out.println(Thread.currentThread().getName() + "***"+ ticket--);      
             } while (ticket > 0);
            }
        }
        public static void main(String[] args) {
                Demo d = new Demo();
                Thread t1 = new Thread(d);
                Thread t2 = new Thread(d);
                Thread t3 = new Thread(d);
                Thread t4 = new Thread(d);
                t1.start();
                t2.start();
                t3.start();
                t4.start();
        }
}
因为有一个线程抢到了执行权以后，就一直在循环中，因为条件一直为真，没有机会释放CPU执行权，等到条件为0时，才跳出循还，释放执行权，此时CPU又切换到其他线程，因为没有判断约束条件，当行执到输出时，就会出现小于0的情况。

按照你的写法，一个线程得到锁，进去了，就一直在循环，知道将票卖完才退出，释放锁；第二个线程进入了，不判断票数，直接执行，这时候，产生的负数票，然后判断，退出循环；接下来的线程都在重复这个步骤。解决办法是使用while循环，将同步代码块放入while中

Java菜鸟飘过，向各位大神学习中.....

罗海清 发表于 2012-12-24 09:08
1、这个非常简单了
2、假如ticket等于0了，然后在第18句，好，放弃了执行权，就是没有读到while条件语句。
...

犀利啊，有点像毕老师的风范。。。二话不说都用上了。

java技术菜鸟，现在看不懂这些程序，就知道些函数，但是我肯定很快我就会认识他们了

有点迷糊,还得多看论坛前辈的提问啊

多谢        

1、这个非常简单了
2、假如ticket等于0了，然后在第18句，好，放弃了执行权，就是没有读到while条件语句。
3、这时，另外一个线程来了，二话不说，先执行do再说，这时就输出ticket等于0了，然后再ticket减去1！
4、所以如果这时，这个线程在while条件之前，又挂着了，继续下去，还可能出现负数

你这个程序肯定会出现票数负数的情况，这个条件判断放的位置就不对
do {
                        try {
                                Thread.sleep(10);
                        } catch (InterruptedException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + "***"
                                        + ticket--);
                } while (ticket > 0);}
你的问题在这段代码中
更改的方式如下：
public class Demo implements Runnable {
        private int ticket = 100;
        Object obj = new Object();

        @Override
        public void run() {
                synchronized (obj) {
                        
                while (ticket > 0){
                        try {
                                Thread.sleep(10);
                        } catch (InterruptedException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + "***"
                                        + ticket--);
                } }
        }

        public static void main(String[] args) {
                Demo d = new Demo();
                Thread t1 = new Thread(d);
                Thread t2 = new Thread(d);
                Thread t3 = new Thread(d);
                Thread t4 = new Thread(d);

                t1.start();
                t2.start();
                t3.start();
                t4.start();

        }

}
自己找找区别，这个不会出现负数的情况

一个县城进去就一直循环了……