class Ticked extends Thread
{
        private static int tick = 100;
        Object obj=new Object();
        public void run()
        {
                while (true)
                {
                        synchronized(obj)
                        {
                                if (tick>0)
                                {
                                        try{Thread.sleep(10);}catch(Exception e) {}
                                        System.out.println(this.getName()+"还剩"+tick--+"票");
                                        ;
                                }
                        }
                }
        }
}

class Tick
{
        public static void main(String[] args)
        {
                Ticked t1 = new Ticked();
                Ticked t2 = new Ticked();
                t1.start();
                t2.start();
        }
}
为什么这样还能打出0号票来呢？求解！

Ticked t1 = new Ticked();
Ticked t2 = new Ticked();
你这两个线程操作一个共享数据private static int tick = 100;  当然会出现这个错误，你把你程序改为Ticked t1 = new Ticked();
Thread th1 = new Thread(t1);
Thread th2 = new Thread(t1);
th1.start();
th2.start();  你再试试。

你创建了两个线程对象，使用Object obj=new Object()创建了两个不同的对象，使用了不同的锁。

1. class Ticked extends Thread
   
2. {
   
3.         private static int tick = 100;
   
4.                
   
5.                 Object obj;
   
6.                 public Ticked(Object obj)
   
7.                 {
   
8.                         this.obj=obj;
   
9.                 }
   
10.         
    
11.         public void run()
    
12.         {
    
13.                 while (true)
    
14.                 {
    
15.                         synchronized(obj)
    
16.                         {
    
17.                                 if (tick>0)
    
18.                                 {
    
19.                                         try{Thread.sleep(10);}catch(Exception e) {}
    
20.                                         System.out.println(this.getName()+"还剩"+tick--+"票");
    
21.                                         //;
    
22.                                 }
    
23.                         }
    
24.                 }
    
25.         }
    
26. }
    
27. 
    
28. class Tick
    
29. {
    
30.         public static void main(String[] args)
    
31.         {
    
32.                                 Object obj=new Object();
    
33.                 Ticked t1 = new Ticked(obj);
    
34.                 Ticked t2 = new Ticked(obj);
    
35.                 t1.start();
    
36.                 t2.start();
    
37.         }
    
38. }

复制代码

如果使用继承Thread用上面的代码试一下。
最好实现Runnable，由一个对象创建多个进程，数据是共享的。

你用的不是共享数据，两个线程各持有一份ticket

杨朝辉 发表于 2012-3-23 19:34
你创建了两个线程对象，使用Object obj=new Object()创建了两个不同的对象，使用了不同的锁。 ...

关键的问题可不是这个哦

房宝彬 发表于 2012-3-24 00:39
关键的问题可不是这个哦

如果使用两个线程对象对类中同一个成员变量操作，只能将成员变量声明成静态的。不知道关键点在哪？

Ticked t1 = new Ticked();  t1.start();
哥们，首先你没有创建线程，而且使用的是两个对象。只是两个对象在调用一把加了锁的方法。
这不叫多线程；Ticked 只是继承了Thread类，所以俩对象都可以使用父类的start方法。

主函数中，你应该修改成：
Ticked t = new Ticked();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
t1.start();
t2.start();