Java牛角尖【009】： 多线程中synchronized的锁定方式

同一个对象中的一个synchronized方法如果已有一个线程进入，则其它的线程必须等该线程结束后才能进入该方法。那么，如果一个类中有多个synchronized方法，会有什么情况呢？ 
  看下面一段代码： 

1.  public class Test {
2.      static Test t = new Test();
3.      static Test2 t2 = new Test2();
4.
5.      public static void main(String[] args) {
6.          // TODO Auto-generated method stub
7.
8.          TestThread tt = t.new TestThread();
9.          tt.start();
10.         try {
11.             Thread.sleep(1000);
12.         } catch (InterruptedException e) {
13.             // TODO Auto-generated catch block
14.             e.printStackTrace();
15.         }
16.         t2.test1();
17.     }
18.
19.     class TestThread extends Thread {
20.         @Override
21.         public void run() {
22.             // TODO Auto-generated method stub
23.             t2.test2();
24.         }
25.     }
26. }
27.
28. class Test2 {
29.     public synchronized void test1() {
30.         System.out.println("test1 called");
31.     }
32.
33.     public synchronized void test2() {
34.         System.out.println("test2 called");
35.         try {
36.             Thread.sleep(3000);
37.         } catch (InterruptedException e) {
38.             // TODO Auto-generated catch block
39.             e.printStackTrace();
40.         }
41.         System.out.println("test2 exit");
42.     }
43. }

  运行结果如下： 

1.  test2 called
2.  test2 exit
3.  test1 called

  很明显，当对象t2的synchronized方法test2被线程tt调用时，主线程也无法进入其test1方法，直到线程tt对test2方法的调用结束，主线程才能进入test1方法。 
  结论，对于synchronized方法，Java采用的是对象锁定的方式，当任何一个synchronized方法被访问的时候，该对象中的其它synchronized方法将全部不能被访问。