当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法?

当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法?

日前在网上见到一道Java笔试试题，如题所述。给出的答案如下：

答：不能，一个对象的一个synchronized方法只能由一个线程访问。

本人认为有些所答非所问。故写了两个demo进行测试。发现答案要分三种情况讨论。

• 情况一：

当一个线程进入一个对象的一个synchronized方法后，其它线程访问该对象的非同步方法。
代码如下：

Java代码

1. package com.mutithreading.Object;   
2.   
3. public class InvokedObject  
4. {  
5.     public synchronized void synchronizedMethod()  
6.     {  
7.        System.out.println("Invoked synchronizedMethod !") ;  
8.        try {  
9.            Thread.sleep(10000) ;  
10.        } catch (InterruptedException e) {  
11.            e.printStackTrace();  
12.        }  
13.     }  
14.   
15.     public void generalMethod()  
16.     {  
17.        System.out.println("Invoked generalMethod ...") ;  
18.     }  
19. }  
20.   
21. package com.mutithreading.threads;  
22. import com.mutithreading.Object.InvokedObject;  
23.   
24. public class ThreadOne implements Runnable {  
25.     private InvokedObject object ;  
26.     public ThreadOne(InvokedObject object)  
27.     {  
28.        this.object = object ;  
29.     }  
30.     public void run() {  
31.        object.synchronizedMethod() ;  
32.     }  
33. }  
34.   
35. package com.mutithreading.threads;  
36.   
37. import com.mutithreading.Object.InvokedObject;  
38. public class ThreadTwo implements Runnable {  
39.     private InvokedObject object ;  
40.     public ThreadTwo(InvokedObject object)  
41.     {  
42.        this.object = object ;  
43.     }  
44.     public void run() {  
45.        // TODO Auto-generated method stub  
46.        object.generalMethod() ;  
47.     }  
48. }  
49.   
50. package com.mutithreading.client;  
51. import com.mutithreading.Object.InvokedObject;  
52. import com.mutithreading.threads.ThreadOne;  
53. import com.mutithreading.threads.ThreadTwo;  
54.   
55. public class Client {  
56.     public static void main(String[] args) {  
57.     InvokedObject object = new InvokedObject() ;  
58.     ThreadOne one = new ThreadOne(object) ;  
59.     ThreadTwo two = new ThreadTwo(object) ;  
60.     Thread threadOne = new Thread(one) ;  
61.     Thread threadTwo = new Thread(two) ;  
62.    
63.     threadOne.start() ;  
64.     threadTwo.start() ;  
65. }  
66. }  

运行结果：

一个线程在访问一个对象的同步方法时，另一个线程可以同时访问这个对象的非同步方法。

• 情况二：

当一个线程进入一个对象的一个synchronized方法后，其它线程也访问该同步方法。


运行结果：

一个线程在访问一个对象的同步方法时，另一个线程不能同时访问这个同步方法。（代码略）

• 情况三：

当一个线程进入一个对象的一个synchronized方法后，其它线程同时访问该对象的另一个同步方法。

此处仅给出对InvokedObject类做出的修改代码：

Java代码

1. package com.mutithreading.Object;  
2. public class InvokedObject  
3. {  
4.     public synchronized void synchronizedMethod1()  
5.     {  
6.        System.out.println("Invoked synchronizedMethod1 !") ;  
7.        try {  
8.            Thread.sleep(10000) ;  
9.        } catch (InterruptedException e) {  
10.            e.printStackTrace();  
11.        }  
12.     }     
13.     public synchronized void synchronizedMethod2()  
14.     {  
15.        System.out.println("Invoked synchronizedMethod2 !") ;  
16.     }  
17. }  

运行结果：

一个线程在访问一个对象的同步方法时，另一个线程不能同时访问这个对象的另一个同步方法。