这个程序 我的意图是想让三个线程一共卖100张票，但是每次运行的时候总是一个线程将100张票全部卖完。我已经在

run（）方法中加入了Thread.sleep(1000);语句，感觉程序遇到这句时应该当前线程休眠，其他线程执行，不应该只有一

个线程执行呀？求高人指点？

您的任何帮助，我将不尽感激。

package com.cbd.zhixiang;


public class ThreadDemo
{
public static void main(String[] args)
{
        Ticket t = new Ticket();
        new Thread(t).start();
        new Thread(t).start();
        new Thread(t).start();
}
}


class Ticket  implements Runnable
{
private int count = 100;


Object obj = new Object();
public void run()
{
synchronized (obj)
{

while (count > 0)
{
try
{
Thread.sleep(1000);
} catch (InterruptedException e)
{
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "..."
+ count--);
}
}
}
}

修改下就能运行了

1. public class ThreadDemo{
   
2.         public static void main(String[] args){
   
3.         Ticket t = new Ticket();
   
4.         //创建对象并创建三个线程
   
5.         new Thread(t).start();
   
6.         new Thread(t).start();
   
7.         new Thread(t).start();
   
8.         }
   
9. }
   
10. 
    
11. 
    
12. class Ticket  implements Runnable{
    
13.         private int count = 100;
    
14. 
    
15. 
    
16.         Object obj = new Object();
    
17.         public void run(){
    
18.                 while (count > 0){
    
19.                         try{
    
20.                                 Thread.sleep(1000);
    
21.                         }
    
22.                         catch(InterruptedException e){
    
23.                                 e.printStackTrace();
    
24.                         }
    
25.                         synchronized (obj){
    
26.                                 //同步代码块的位置应该放在这，因为如果你把sleep()方法也扩进去的话，线程是在同步的时候sleep()其他线程也没有办法抢到锁来运行，所以结果才会一个线程运行
    
27.                                 if(count > 0){
    
28.                                         //在这里加一层判断，防止出现负票
    
29.                                         System.out.println(Thread.currentThread().getName() + "..."+ count--);
    
30.                                 }
    
31.                         }
    
32.                 }
    
33.         }
    
34. }

复制代码

class Test3
{
        public static void main(String[] args)
        {
                Ticket t=new Ticket();
                new Thread(t).start();
                new Thread(t).start();
                new Thread(t).start();
        }
}
class Ticket  implements Runnable
{
        private int count=100;
        Object obj = new Object();
        public void run()
        {
                System.out.println("多线程启动!");
                //synchronized (obj)//这一步,你的锁定义在这里,相当于定义在run方法上了,就完全是单线程了.
                //{
                        while (count > 0)
                        {
                                try
                                {Thread.sleep(10);} //线程在这里停多了.到最后票要卖完了.那么线程,还是会再卖一票,程序也会出错,
                                catch (InterruptedException e)
                                {e.printStackTrace();}
                                synchronized(obj)
                                {
                                        if(count>0)//加上一层判断,阻止票卖完了,还有沉睡的线程进来继续卖.
                                                System.out.println(Thread.currentThread().getName()+"..."+count--);
                                }
                        }
                //}
        }
}

陈圳 发表于 2013-3-4 23:07
class Test3
{
        public static void main(String[] args)

哈哈，我两基本说的一模一样