关于售票这个问题，我用继承Tread方法，在毕老师是将票数直接在输出里tick--，我将它放到下边为什么就不行啦，是多线程安全的问题吗？那为什么加入同步代码块也不行？麻烦各位帮忙看下，谢谢啦
public class threadTest {
/**
  * @param args
  */
public static void main(String[] args) {
  // TODO Auto-generated method stub
        c t0= new c();
        c t1= new c();
        c t2= new c();
        t0.start();
        t1.start();
        t2.start();
}
}
class c extends Thread
{
private static int count=100;
public void run()
{
  while(true){
   synchronized (this) {
    if(count>0)
    {
     System.out.println(Thread.currentThread().getName()+":"+count);
     count--;      //我将递减放到下面为什么会出现重复的数，如果是多线程安全问题，为什么同步代码块也不行
    }
    else{
      return;
     }
   }
   
   }
   
  }
}

你确定毕老师是这么教你同步的么？

aaaaaaaaaaaaaaaaaaaaaaaa

很明显你的锁对象this 是 c0 c1 c2 根本就不相同，所以根本就没有同步

1. public class ThreadTest {
   
2.         /**
   
3.          * @param args
   
4.          */
   
5.         public static void main(String[] args) {
   
6.                 // TODO Auto-generated method stub
   
7.                 c cc = new c();
   
8.                 Thread t0 = new Thread(cc);
   
9.                 Thread t1 = new Thread(cc);
   
10.                 Thread t2 = new Thread(cc);
    
11.                 t0.start();
    
12.                 t1.start();
    
13.                 t2.start();
    
14.         }
    
15. }
    
16. 
    
17. class c implements Runnable {
    
18.         private static int count = 1000;
    
19. 
    
20.         public void run() {
    
21.                 while (true) {
    
22.                         synchronized (this) {
    
23.                                 if (count > 0) {
    
24.                                         System.out.println(Thread.currentThread().getName() + ":"
    
25.                                                         + count);
    
26.                                 } else {
    
27.                                         return;
    
28.                                 }
    
29.                                 count--; // 我将递减放到下面为什么会出现重复的数，如果是多线程安全问题，为什么同步代码块也不行
    
30.                         }
    
31. 
    
32.                 }
    
33. 
    
34.         }
    
35. }

复制代码

1. public class ThreadTest {
   
2.         /**
   
3.          * @param args
   
4.          */
   
5.         public static void main(String[] args) {
   
6.                 // TODO Auto-generated method stub
   
7.                 c t0 = new c();
   
8.                 c t1 = new c();
   
9.                 c t2 = new c();
   
10.                 t0.start();
    
11.                 t1.start();
    
12.                 t2.start();
    
13.         }
    
14. }
    
15. 
    
16. class c extends Thread {
    
17.         private static int count = 1000;
    
18. 
    
19.         public void run() {
    
20.                 while (true) {
    
21.                         synchronized (c.class) {
    
22.                                 if (count > 0) {
    
23.                                         System.out.println(Thread.currentThread().getName() + ":"
    
24.                                                         + count);
    
25.                                 } else {
    
26.                                         return;
    
27.                                 }
    
28.                                 count--; // 我将递减放到下面为什么会出现重复的数，如果是多线程安全问题，为什么同步代码块也不行
    
29.                         }
    
30. 
    
31.                 }
    
32. 
    
33.         }
    
34. }

复制代码

上面是两种同步执行的方法
第一种是c这个类 去实现Runable接口，此时使用new Thread去创建一个线程，并将c的对象cc作为每个线程的执行对象，因为三个线程使用的是同一个对象，也就是所synchronized是使用同一把锁，所以可以实现同步

第二种方法是继承Thread类  这时如果要开启多个线程可能就需要去new多个c的对象了，如果是多个对象，使用synchronized(this)肯定是不行的，this表示的是当前类的对象，new了3个对象就是开辟了3块内存，自己使用自己的锁何谈同步呢！所以要使用c.class 使用类的字节码作为同步锁，因为类是唯一的，而对象是可以有多个的。


你自己的方法你可以多执行几次，可以发现即便是count--在你现在写的位置也是会出现重复数据的，因为你就是new了多个对象，而让你看起来貌似正确的原因就是你的count定义为static，定义为静态之后count这个变量就是一个全局变量了，也就是说每个操作都会影响其值。

不知道能不能理解，欢迎留言讨论。  
上个回复没写完，一着急发了一堆乱七八糟的东西  见谅。

强子 发表于 2014-1-15 17:22
上面是两种同步执行的方法
第一种是c这个类 去实现Runable接口，此时使用new Thread去创建一个线程， ...

非常感谢，已经明白啦