//问题：
//假设有火车票100张，创建10个线程模拟10个售票点，每个售票点500毫秒买一张票。打印出售票过程，注意使用synchronized确保同一张票只能卖出一次。

class TicketsSell implements Runnable {
         
   
         static int tickets=1;//实例化票数
    int num;

    public TicketsSell(int num) {//  构造方法
        this.num = num;
    }

    public  synchronized void run() {
      //synchronized(this){// 同步该方法
        for (int i=0; i< 100; i++) {
               

           if(tickets<100) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("第" + num + "售票点卖出第" + (tickets++) + "张票");
   
            }
            
           }
           
      
    }
}

public class Station {

    public static void main(String[] args) {
        
       Thread wicket1 = new Thread(new TicketsSell(1));
        Thread wicket2 = new Thread(new TicketsSell(2));
        Thread wicket3 = new Thread(new TicketsSell(3));
        Thread wicket4 = new Thread(new TicketsSell(4));
        Thread wicket5 = new Thread(new TicketsSell(5));
        Thread wicket6 = new Thread(new TicketsSell(6));
        Thread wicket7 = new Thread(new TicketsSell(7));
        Thread wicket8 = new Thread(new TicketsSell(8));
        Thread wicket9 = new Thread(new TicketsSell(9));
        Thread wicket10 = new Thread(new TicketsSell(10));
        wicket1.start();
        wicket2.start();
        wicket3.start();
        wicket4.start();
        wicket5.start();
        wicket6.start();
        wicket7.start();
        wicket8.start();
        wicket9.start();
        wicket10.start();
      
    }

}
运行结果： 为什么会超出100张！ 我找不出错误，知道的说下！

      System.out.println("第" + num + "售票点卖出第" + (tickets++) + "张票");
                  try {
                     Thread.sleep(500);   
                  } catch (InterruptedException e) {e.printStackTrace();}
这样写没有溢出，eclipse编辑器下，5遍。。

第1售票点卖出第1张票
第2售票点卖出第1张票
第3售票点卖出第1张票
第5售票点卖出第1张票
第7售票点卖出第1张票
第6售票点卖出第1张票
第4售票点卖出第1张票
第8售票点卖出第1张票
第9售票点卖出第1张票
第10售票点卖出第1张票
这里有点不对劲。。。。

是会溢出。。我觉得在调用每个线程的时候用个join（）方法就可以。。有点笨，呵呵。

这样锁住的是对象，不是类，没有达到同步的作用。

你可以用同步块这样写：

synchronized (TicketsSell.class) {
    // 这里写对TicketsSell.tickets的操作
}

[ 本帖最后由 buffer 于 2011-4-15 22:42 编辑 ]

那是锁定方法，在think in java 里也有这样用的，但好像没有在Thread.run()上用synchronized的，我在run()方法里用了synchronized，和你的一样。。。

回复 7楼 llooppzhang
public synchronized void run()和synchronized(this){...}的作用是一样的，锁住的都是对象，也就是说
虽然同一个对象不能在不同线程内同时调用这个方法。但是不同的对象却可以同时访问该方法。
所以这样那十个线程并没有获得同步控制。
而synchronized(TicketsSell.class){...}锁住的是TicketsSell这个类。这样就可以同步TicketsSell的静态成员tickets。

// Sync.java
public class Sync {
    public static void main(String[] args) {
        Thread[] threads = new Thread[10];
        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread(new Ticket(i + 1));
            threads[i].start();
        }
    }
}

class Ticket implements Runnable {
    private static final int TOTAL_TICKETS = 100;
    static int countTicket = 1;
    int number;

    public Ticket(int num) {
        number = num;
    }

    @Override
    public void run() {
        for (int i = 1; i <= TOTAL_TICKETS; i++) {
            try {
                Thread.sleep(500);
            } catch (Exception e) {
                e.printStackTrace();
            }
            synchronized (Ticket.class) {
                if (Ticket.countTicket <= TOTAL_TICKETS) {
                    System.out.println("第" + number + "售票点卖出第"
                            + (Ticket.countTicket++) + "张票");
                }
            }
        }
    }
}

收到的鲜花

• 诸葛修勤 于 2011-04-17 19:05 送鲜花  8朵  

程序运行输出：

 Thread[] threads = new Thread[10];

这句怎么理解？