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

这个要看是同步方法还是非同步方法了。
如果是同步方法的话是不可以的。
如果是非同步方法的话是可以的。
我用代码来演示下。

1. package Test;
   
2. 
   
3. public class Test1
   
4. {
   
5.         public static void main(String[] args)
   
6.         {
   
7.                 ThreadDemo threadDemo=new ThreadDemo();
   
8.                 Thread t1=new ThreadOne(threadDemo);
   
9.                 Thread t2=new ThreadTwo(threadDemo);
   
10.                 Thread t3=new ThreadThree(threadDemo);
    
11.                 t1.start();
    
12.                 t2.start();
    
13.                 t3.start();
    
14. 
    
15.         }
    
16. 
    
17. }
    
18. 
    
19. class ThreadDemo
    
20. {
    
21. 
    
22.         public synchronized void method1()
    
23.         {
    
24.                 for (int i = 0; i < 10; i++)
    
25.                 {
    
26.                         try
    
27.                         {
    
28.                                 Thread.sleep(500);
    
29.                         } catch (InterruptedException e)
    
30.                         {
    
31.                                 e.printStackTrace();
    
32.                         }
    
33.                         System.out.println("同步方法1"+"    "+ i);
    
34.                 }
    
35.         }
    
36. 
    
37.         public synchronized void method2()
    
38.         {
    
39.                 for (int i = 0; i < 10; i++)
    
40.                 {
    
41.                         try
    
42.                         {
    
43.                                 Thread.sleep(500);
    
44.                         } catch (InterruptedException e)
    
45.                         {
    
46.                                 e.printStackTrace();
    
47.                         }
    
48.                         System.out.println("同步方法2"+"    " + i);
    
49.                 }
    
50.         }
    
51. 
    
52.         public void Print()
    
53.         {
    
54.                 for (int i = 0; i < 10; i++)
    
55.                 {
    
56.                         try
    
57.                         {
    
58.                                 Thread.sleep(500);
    
59.                         } catch (InterruptedException e)
    
60.                         {
    
61.                                 e.printStackTrace();
    
62.                         }
    
63.                         System.out.println("非同步方法" + i);
    
64.                 }
    
65.         }
    
66. }
    
67. 
    
68. class ThreadOne extends Thread
    
69. {
    
70.         private ThreadDemo threadDemo;
    
71. 
    
72.         public ThreadOne(ThreadDemo threadDemo)
    
73.         {
    
74.                 this.threadDemo = threadDemo;
    
75.         }
    
76. 
    
77.         public void run()
    
78.         {
    
79.                 this.threadDemo.method1();
    
80.         }
    
81. }
    
82. 
    
83. class ThreadTwo extends Thread
    
84. {
    
85.         private ThreadDemo threadDemo;
    
86. 
    
87.         public ThreadTwo(ThreadDemo threadDemo)
    
88.         {
    
89.                 this.threadDemo = threadDemo;
    
90.         }
    
91. 
    
92.         public void run()
    
93.         {
    
94.                 this.threadDemo.method2();
    
95.         }
    
96. }
    
97. 
    
98. class ThreadThree extends Thread
    
99. {
    
100.         private ThreadDemo threadDemo;
     
101. 
     
102.         public ThreadThree(ThreadDemo threadDemo)
     
103.         {
     
104.                 this.threadDemo = threadDemo;
     
105.         }
     
106. 
     
107.         public void run()
     
108.         {
     
109.                 this.threadDemo.Print();
     
110.         }
     
111. 
     
112. }
     

复制代码

定义ThreadDemo类 有三个方法metho1，method2，Print。
其中metho1，method2为同步方法。Print为非同步方法。
如果在主函数中只开启t1.start()和t2.start();则输出结果为
t1输出完后，t2在输出。所以如果是同步方法的话是不可以的。

如果在主函数中只开启t1.start()和t3.start();则输出结果为
t1，Print交替输出。所以如果是非同步方法的话是可以的。

如果这个对象中有多个方法都上了锁,而且上锁的方法中内部调用了wait,那有wait的线程执行到wait会释放执行权给其他上锁的线程.