如果有同同一个对象作为synchroized（x）的参数，该参数x如果先在一个线程中被锁定，比如锁定后sleep（10000），在这段时间里，他在其他的线程中也作为synchroized（x）的参数时，这个线程能不能正常运行啊？

不能正常运行 线程被冻结了 只能等到冻结时间1000ms 结束该同步才线程才能运行

1. class  TestThread
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 new Thread(new RunClass(0)).start();
   
6.                 new Thread(new RunClass(1)).start();
   
7.                 System.out.println("Hello World!");
   
8.         }
   
9. }
   
10. 
    
11. class RunClass implements Runnable
    
12. {
    
13.         int flag=0;
    
14.         public RunClass(int flag)
    
15.         {
    
16.                 this.flag=flag;
    
17.         }
    
18. 
    
19.         public void run()
    
20.         {
    
21.                 String str ="";
    
22.                 while(true)
    
23.                 {
    
24.                         if(flag==0)
    
25.                         {
    
26.                                 Test.fun1(str);
    
27.                         }
    
28.                         else
    
29.                         {
    
30.                                 Test.fun2(str);
    
31.                         }
    
32.                 }
    
33.         }
    
34. }
    
35. 
    
36. class Test
    
37. {
    
38.         public static void fun1(String str)
    
39.         {
    
40.                 synchronized(str)
    
41.                 {
    
42.                         System.out.println("start Sleep");
    
43.                         try{Thread.sleep(1000);}catch(Exception e){}
    
44.                         System.out.println("end Sleep");
    
45.                         System.out.println("fun1:"+str);
    
46. 
    
47.                 }
    
48.         }
    
49. 
    
50.         public static void fun2(String str)
    
51.         {
    
52.                 synchronized(str)
    
53.                 {
    
54.                         System.out.println("fun2:"+str);
    
55.                 }
    
56.         }
    
57. }
    

复制代码

你看我上面这个代码的结果中
start Sleep
end Sleep
之间是没有其他值的。也就是调用fun1的代码时，线程1 sleep了，线程2也是不执行的。因为使用的是同一个x参数

线程对象Sleep（10000）秒，但是他并不放弃CPU的执行权，锁还是在它的手里，所以其他同他一个锁的线程对象是不会获得CPU的执行权。

按照我个人的理解是这样的，在线程进行sleep或者wait的时候，此时该线程是释放了执行资格个执行权的，但是它没有释放同步锁，此时，就算其他的线程得到了执行权，但是它没有得到同步锁，所以其他线程也是不能执行同步代码块或同步函数的，这就是毕老师所说的为什么线程在sleep结束或notify后会进入临时阻塞状态，当cpu切换到拥有同步锁的线程后，该线程就继续执行同步代码块或者同步函数。