大神们！我想用同步方法，还有就是多个服务器，多个线程，把100张票卖掉，每个线程剩余的票数不能有重复，这该怎么做啊！以下是我的错误代码，还望大神帮我改一下：

1. 
   
2. class Duo implements Runnable
   
3. {
   
4.         int piao = 100;
   
5.         //public static Object obj = new Object();
   
6. 
   
7.         public void run()
   
8.         {
   
9.                 while(true)
   
10.                 {
    
11.                         sale();
    
12.                 }
    
13.                        
    
14.         }
    
15. 
    
16.         public synchronized void sale()
    
17.         {
    
18.                
    
19.                 if(piao > 0)
    
20.                 {
    
21.                         System.out.println(Thread.currentThread().getName() + ":" + piao);
    
22.                         piao--;
    
23. 
    
24.                         notifyAll();
    
25.                         try
    
26.                         {
    
27.                                 wait();
    
28.                         }
    
29.                         catch (Exception e)
    
30.                         {
    
31.                         }
    
32.                        
    
33.                 }
    
34.         }
    
35. }
    
36. 
    
37. class Suo
    
38. {
    
39.         public static void jiaSuo()
    
40.         {
    
41.                 System.out.println("我加锁了<--->");
    
42.         }
    
43. }
    
44. 
    
45. public class DuoXian
    
46. {
    
47.         public static void main(String args[])
    
48.         {
    
49.                 Duo duo = new Duo();
    
50.                 Duo duo1 = new Duo();
    
51.                 Duo duo2 = new Duo();
    
52. 
    
53.                 Thread s = new Thread(duo);
    
54.                 Thread s2 = new Thread(duo1);
    
55.                 Thread s3 = new Thread(duo2);
    
56. 
    
57.                 s.start();
    
58.                 s2.start();
    
59.                 s3.start();
    
60. 
    
61.                 //System.out.println(Thread.currentThread().getName());
    
62.         }
    
63. }

复制代码

这是错误的效果：

class Suo
{
        public static void jiaSuo()
        {
                System.out.println("我加锁了<--->");
        }
}
这个干么用的

public class Test014
{
        static int count = 1000000;
       
        public static void main(String[] args)
        {
                long startTime = System.currentTimeMillis();
                Object obj = new Object();
                Thread ck1 = new Thread(new Window1(obj),"窗口11111");
                Thread ck2 = new Thread(new Window2(obj),"窗口222");
                Thread ck3 = new Thread(new Window3(obj),"窗口33333333333");
                ck1.start();
                ck2.start();
                ck3.start();
                try
                {
                        ck1.join();
                        ck2.join();
                        ck3.join();
                } catch (InterruptedException e) {
                       
                        e.printStackTrace();
                }
               
                long endTime = System.currentTimeMillis();
                System.out.println("3个窗口卖 1000000 张票共耗时：" + (endTime - startTime)/1000 + "秒");
               
        }

}

class Window1 implements Runnable
{
        int window1Count=0;
        private Object obj;
        Window1(Object obj)
        {
                this.obj = obj;
        }
        public void run()
        {
                while(Test014.count > 0)
                {
                        synchronized(obj)
                        {
                                if(Test014.count > 0)
                                {
                                        window1Count++;
                                        Test014.count --;
                                        System.out.println(Thread.currentThread().getName() +
                                                "卖出一张票，现在还剩：" + Test014.count + "共计卖出：" + window1Count);
                                }
                        }
                }       
        }
}
class Window2 implements Runnable
{
        int window2Count=0;
        private Object obj;
        Window2(Object obj)
        {
                this.obj = obj;
        }

        public void run()
        {
                while(Test014.count > 0)
                {
                        synchronized(obj)
                        {
                                if(Test014.count > 0)
                                {
                                        window2Count++;
                                        Test014.count --;
                                        System.out.println(Thread.currentThread().getName() +
                                                "卖出一张票，现在还剩：" + Test014.count + "共计卖出：" + window2Count);
                                }
                        }
               
                }
        }
}
class Window3 implements Runnable
{
        int window3Count=0;
        private Object obj;
        Window3(Object obj)
        {
                this.obj = obj;
        }
       
        public void run()
        {
                while(Test014.count > 0)
                {
                        synchronized(obj)
                        {
                                if(Test014.count > 0)
                                {       
                                        window3Count++;
                                        Test014.count --;
                                        System.out.println(Thread.currentThread().getName() +
                                        "卖出一张票，现在还剩：" + Test014.count + "共计卖出：" + window3Count);
                                }
                        }
                       
                }
        }
}

你写wait放在notifyAll,线程就挂起了,当然卖不下去了.而且你创建了3个Duo对象,是要卖300张票?

masai158 发表于 2014-7-31 16:53
public class Test014
{
        static int count = 1000000;

嗯...，大神！能不能做到窗口1卖一张，窗口2卖一张，窗口3卖一张，然后再窗口1卖一张..............，这样可不可以啊！还请大神指教指教！{:2_32:}

1. package com.chapter3;
   
2. 
   
3. class Xc2 implements Runnable
   
4. {
   
5.        
   
6.         public static int cp=100;
   
7.         static String aa= new String("1");
   
8.        
   
9.         public void run()
   
10.         {
    
11.                 while(true)
    
12.                 {
    
13.                         synchronized (aa)
    
14.                         {
    
15.                             if(cp>0)
    
16.                             {
    
17.                                     System.out.println("第"+Thread.currentThread().getName()+"个车站正在卖第"+(101-cp)+"张车票");
    
18.                         --cp;                       
    
19.                             }else
    
20.                             {
    
21.                                      break;
    
22.                                
    
23.                             }
    
24.                         }
    
25.                 }
    
26.                
    
27.         }
    
28. 
    
29. }
    
30. 
    
31. public class Xc
    
32. {
    
33.         public static void main(String[] args)
    
34.         {
    
35.                 Xc2 xc2_1 = new Xc2();
    
36.                 Thread ee= new Thread(xc2_1);
    
37.                 ee.start();
    
38.                
    
39.                 Xc2 xc2_2 = new Xc2();
    
40.                 Thread ff= new Thread(xc2_2);
    
41.                 ff.start();
    
42.         }
    
43. 
    
44. }

复制代码

这是之前看教程的时候照着敲过的，不会重复卖票，不过100张票有时候看不出效果，至于每个线程走一次，用：this.wait();让当前线程进入等待状态

this.notify();叫醒另外一个线程

这两个方法不知道可不可以实现，没有试过……  

楼上正解。。。

确实，学到不少

小白马__^o^ 发表于 2014-7-31 20:57
嗯...，大神！能不能做到窗口1卖一张，窗口2卖一张，窗口3卖一张，然后再窗口1卖一张..............，这 ...

卖一张就睡觉。等待其他线程唤醒。
1卖了，睡觉。。只 唤醒2.
2卖了，睡觉。。。只 唤醒3
3卖了，睡觉。。只唤醒1

知识回顾，赞

                Duo duo = new Duo();
                Duo duo1 = new Duo();
                Duo duo2 = new Duo();

                Thread s = new Thread(duo);
                Thread s2 = new Thread(duo1);
                Thread s3 = new Thread(duo2);
创建了三个资源,三个线程都在执行不同的资源,所以
                        notifyAll();
                        try {
                                wait();
                        } catch (Exception e) {
                        }
都不能唤醒其他两个线程,所以都是卖了一张票就wait()了.
解决方法,只能new 一个DUo,让三个线程执行一个资源.
重点                Duo duo = new Duo();
                Thread s = new Thread(duo);
                Thread s2 = new Thread(duo);
                Thread s3 = new Thread(duo);