1. public class TT implements Runnable {
   
2. int b = 100;
   
3. 
   
4. public synchronized void m1() throws Exception{
   
5.   //Thread.sleep(2000);
   
6.   b = 1000;
   
7.   Thread.sleep(1000);
   
8.   System.out.println("b = " + b);
   
9. }
   
10. 
    
11. public synchronized void m2() throws Exception {
    
12.   b = 2000;
    
13.   Thread.sleep(10500);
    
14.   
    
15.   System.out.println(b);
    
16. }
    
17. 
    
18. public void run() {
    
19.   try {
    
20.    m1();
    
21.   } catch(Exception e) {
    
22.    e.printStackTrace();
    
23.   }
    
24. }
    
25. 
    
26. public static void main(String[] args) throws Exception {
    
27.   TT tt = new TT();
    
28.   Thread t = new Thread(tt);
    
29.   t.start();
    
30.   tt.m2();
    
31.   
    
32. }
    
33. }
    
34. 程序运行结果是2000
    
35. b = 1000，既m2先执行完，再执行m1方法。可2个方法都上锁了，应该是m1执行完才解锁后开始执行M2才对啊？

复制代码

同步函数是有作用的,只是线程间执行权的抢夺问题.

t.start();//开启t线程
tt.m2();//这一句可以理解为main()线程   也就是主线程.

在程序执行的过程中,主线程和t线程都有执行资格,
相互抢夺执行权
所以两个线程有可能执行,

如果主线程先执行的话,也就是tt.m2();这一句先执行,先打印2000,然后m1()再执行,打印b=1000


同步函数就是只要有人进来就上锁,所有用this锁的同步就都锁上了.





  

public class TT implements Runnable {
int b = 100;

public synchronized void m1() throws Exception{
  //Thread.sleep(2000);
  b = 1000;
  Thread.sleep(1000);
  System.out.println("b = " + b);
}

public synchronized void m2() throws Exception {
  b = 2000;
  Thread.sleep(10500);
  
  System.out.println(b);
}

public void run() {
  try {
   m1();
  } catch(Exception e) {
   e.printStackTrace();
  }
}

public static void main(String[] args) throws Exception {
  TT tt = new TT();
  Thread t = new Thread(tt);
  t.start();
  tt.m2();
  
}
}
程序运行结果是2000
b = 1000，既m2先执行完，再执行m1方法。可2个方法都上锁了，应该是m1执行完才解锁后开始执行M2才对啊？

因为抬头tt 和t 不是同一个对象 而同步函数的默认锁是this  不同对象的不同锁  这两个方法也就不同了 在说你那个也不是m1 是线程对象调用的 而M2方法就是普通的方法调用 所以你这个不存在同步。

张庚 发表于 2013-2-7 15:37
public class TT implements Runnable {
int b = 100;

哦，是这样啊