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

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

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

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交替输出。所以如果是非同步方法的话是可以的。

可以。
Java 中的每个对象都有一个锁，当访问某个对象的synchronized方法时，表示将该对象上锁，
此时其他任何线程都无法访问该synchronized方法了,直到之前的那个线程方法完毕或是抛出了异常，
则该对象将锁释放掉，其他线程才可能去访问该synchronized方法。
如果一个对象有多个synchronized方法，某个线程已经进入到了某个synchronized方法，在该方法没有执行
完毕前，其他线程无法访问该对象的任何synchronized方法，但其它线程可进入此对象的其它方法。

请运行示例：
public class MyThreadTest
{
        public static void main(String[] args)
        {
                Demo example = new Demo();

                Thread t1 = new TheThread33(example);

                Thread t2 = new TheThread44(example);

                Thread t3 = new TheThread55(example);

                t1.start();
                t2.start();
                t3.start();
        }
}

class Demo
{
        public synchronized void execute()
        {
                for (int i = 0; i < 10; i++)
                {
                        try
                        {
                                Thread.sleep(500);
                        }
                        catch (InterruptedException e)
                        {
                                e.printStackTrace();
                        }

                        System.out.println("hello: " + i);
                }
        }

        public synchronized void execute2()
        {
                for (int i = 0; i < 10; i++)
                {
                        try
                        {
                                Thread.sleep(500);
                        }
                        catch (InterruptedException e)
                        {
                                e.printStackTrace();
                        }

                        System.out.println("world: " + i);
                }
        }

        public void output()
        {
                for (int x = 0; x < 10; x++)
                {
                        try
                        {
                                Thread.sleep(600);
                        }
                        catch (InterruptedException e)
                        {
                                e.printStackTrace();
                        }
                        System.out.println("你好啊");
                }
        }

}

class TheThread33 extends Thread
{
        private Demo example;

        public TheThread33(Demo example)
        {
                this.example = example;
        }

        @Override
        public void run()
        {
                this.example.execute();
        }
}

class TheThread44 extends Thread
{
        private Demo example;

        public TheThread44(Demo example)
        {
                this.example = example;
        }

        @Override
        public void run()
        {
                this.example.output();
        }
}

class TheThread55 extends Thread
{
        private Demo example;

        public TheThread55(Demo example)
        {
                this.example = example;
        }

        @Override
        public void run()
        {
                this.example.execute2();
        }
}