java synchronized类锁，对象锁详解（转载）

Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。

     一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

     二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。

     三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

     四、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。

     五、以上规则对其它对象锁同样适用.

对象锁的synchronized修饰方法和代码块：

Java代码    

1. public class TestSynchronized   
2. {    
3.     public void test1()   
4.     {    
5.          synchronized(this)   
6.          {    
7.               int i = 5;    
8.               while( i-- > 0)   
9.               {    
10.                    System.out.println(Thread.currentThread().getName() + " : " + i);    
11.                    try   
12.                    {    
13.                         Thread.sleep(500);    
14.                    }   
15.                    catch (InterruptedException ie)   
16.                    {    
17.                    }    
18.               }    
19.          }    
20.     }    
21.       
22.     public synchronized void test2()   
23.     {    
24.          int i = 5;    
25.          while( i-- > 0)   
26.          {    
27.               System.out.println(Thread.currentThread().getName() + " : " + i);    
28.               try   
29.               {    
30.                    Thread.sleep(500);    
31.               }   
32.               catch (InterruptedException ie)   
33.               {    
34.               }    
35.          }    
36.     }    
37.       
38.     public static void main(String[] args)   
39.     {    
40.          final TestSynchronized myt2 = new TestSynchronized();    
41.          Thread test1 = new Thread(  new Runnable() {  public void run() {  myt2.test1();  }  }, "test1"  );    
42.          Thread test2 = new Thread(  new Runnable() {  public void run() { myt2.test2();   }  }, "test2"  );    
43.          test1.start();;    
44.          test2.start();    
45. //         TestRunnable tr=new TestRunnable();  
46. //         Thread test3=new Thread(tr);  
47. //         test3.start();  
48.     }   
49.     
50. }  

 

 

Java代码    

1. test2 : 4  
2. test2 : 3  
3. test2 : 2  
4. test2 : 1  
5. test2 : 0  
6. test1 : 4  
7. test1 : 3  
8. test1 : 2  
9. test1 : 1  
10. test1 : 0  

 

上述的代码，第一个方法时用了同步代码块的方式进行同步，传入的对象实例是this，表明是当前对象，当然，如果需要同步其他对象实例，也不可传入其他对象的实例；第二个方法是修饰方法的方式进行同步。因为第一个同步代码块传入的this，所以两个同步代码所需要获得的对象锁都是同一个对象锁，下面main方法时分别开启两个线程，分别调用test1和test2方法，那么两个线程都需要获得该对象锁，另一个线程必须等待。上面也给出了运行的结果可以看到：直到test2线程执行完毕，释放掉锁，test1线程才开始执行。（可能这个结果有人会有疑问，代码里面明明是先开启test1线程，为什么先执行的是test2呢？这是因为java编译器在编译成字节码的时候，会对代码进行一个重排序，也就是说，编译器会根据实际情况对代码进行一个合理的排序，编译前代码写在前面，在编译后的字节码不一定排在前面，所以这种运行结果是正常的， 这里是题外话，最主要是检验synchronized的用法的正确性）

 

如果我们把test2方法的synchronized关键字去掉，执行结果会如何呢？

Java代码    

1. test1 : 4  
2. test2 : 4  
3. test2 : 3  
4. test1 : 3  
5. test1 : 2  
6. test2 : 2  
7. test2 : 1  
8. test1 : 1  
9. test2 : 0  
10. test1 : 0  

 

上面是执行结果，我们可以看到，结果输出是交替着进行输出的，这是因为，某个线程得到了对象锁，但是另一个线程还是可以访问没有进行同步的方法或者代码。进行了同步的方法（加锁方法）和没有进行同步的方法（普通方法）是互不影响的，一个线程进入了同步方法，得到了对象锁，其他线程还是可以访问那些没有同步的方法（普通方法）。这里涉及到内置锁的一个概念（此概念出自java并发编程实战第二章）：对象的内置锁和对象的状态之间是没有内在的关联的，虽然大多数类都将内置锁用做一种有效的加锁机制，但对象的域并不一定通过内置锁来保护。当获取到与对象关联的内置锁时，并不能阻止其他线程访问该对象，当某个线程获得对象的锁之后，只能阻止其他线程获得同一个锁。之所以每个对象都有一个内置锁，是为了免去显式地创建锁对象。

 

所以synchronized只是一个内置锁的加锁机制，当某个方法加上synchronized关键字后，就表明要获得该内置锁才能执行，并不能阻止其他线程访问不需要获得该内置锁的方法。

 

类锁的修饰（静态）方法和代码块：

Java代码    

1. public class TestSynchronized   
2. {    
3.     public void test1()   
4.     {    
5.          synchronized(TestSynchronized.class)   
6.          {    
7.               int i = 5;    
8.               while( i-- > 0)   
9.               {    
10.                    System.out.println(Thread.currentThread().getName() + " : " + i);    
11.                    try   
12.                    {    
13.                         Thread.sleep(500);    
14.                    }   
15.                    catch (InterruptedException ie)   
16.                    {    
17.                    }    
18.               }    
19.          }    
20.     }    
21.       
22.     public static synchronized void test2()   
23.     {    
24.          int i = 5;    
25.          while( i-- > 0)   
26.          {    
27.               System.out.println(Thread.currentThread().getName() + " : " + i);    
28.               try   
29.               {    
30.                    Thread.sleep(500);    
31.               }   
32.               catch (InterruptedException ie)   
33.               {    
34.               }    
35.          }    
36.     }    
37.       
38.     public static void main(String[] args)   
39.     {    
40.          final TestSynchronized myt2 = new TestSynchronized();    
41.          Thread test1 = new Thread(  new Runnable() {  public void run() {  myt2.test1();  }  }, "test1"  );    
42.          Thread test2 = new Thread(  new Runnable() {  public void run() { TestSynchronized.test2();   }  }, "test2"  );    
43.          test1.start();    
44.          test2.start();    
45. //         TestRunnable tr=new TestRunnable();  
46. //         Thread test3=new Thread(tr);  
47. //         test3.start();  
48.     }   
49.     
50. }  

 

Java代码    

1. test1 : 4  
2. test1 : 3  
3. test1 : 2  
4. test1 : 1  
5. test1 : 0  
6. test2 : 4  
7. test2 : 3  
8. test2 : 2  
9. test2 : 1  
10. test2 : 0  

 

其实，类锁修饰方法和代码块的效果和对象锁是一样的，因为类锁只是一个抽象出来的概念，只是为了区别静态方法的特点，因为静态方法是所有对象实例共用的，所以对应着synchronized修饰的静态方法的锁也是唯一的，所以抽象出来个类锁。其实这里的重点在下面这块代码，synchronized同时修饰静态和非静态方法

Java代码    

1. public class TestSynchronized   
2. {    
3.     public synchronized void test1()   
4.     {    
5.               int i = 5;    
6.               while( i-- > 0)   
7.               {    
8.                    System.out.println(Thread.currentThread().getName() + " : " + i);    
9.                    try   
10.                    {    
11.                         Thread.sleep(500);    
12.                    }   
13.                    catch (InterruptedException ie)   
14.                    {    
15.                    }    
16.               }    
17.     }    
18.       
19.     public static synchronized void test2()   
20.     {    
21.          int i = 5;    
22.          while( i-- > 0)   
23.          {    
24.               System.out.println(Thread.currentThread().getName() + " : " + i);    
25.               try   
26.               {    
27.                    Thread.sleep(500);    
28.               }   
29.               catch (InterruptedException ie)   
30.               {    
31.               }    
32.          }    
33.     }    
34.       
35.     public static void main(String[] args)   
36.     {    
37.          final TestSynchronized myt2 = new TestSynchronized();    
38.          Thread test1 = new Thread(  new Runnable() {  public void run() {  myt2.test1();  }  }, "test1"  );    
39.          Thread test2 = new Thread(  new Runnable() {  public void run() { TestSynchronized.test2();   }  }, "test2"  );    
40.          test1.start();    
41.          test2.start();    
42. //         TestRunnable tr=new TestRunnable();  
43. //         Thread test3=new Thread(tr);  
44. //         test3.start();  
45.     }   
46.     
47. }  

 

Java代码    

1. test1 : 4  
2. test2 : 4  
3. test1 : 3  
4. test2 : 3  
5. test2 : 2  
6. test1 : 2  
7. test2 : 1  
8. test1 : 1  
9. test1 : 0  
10. test2 : 0  

 

上面代码synchronized同时修饰静态方法和实例方法，但是运行结果是交替进行的，这证明了类锁和对象锁是两个不一样的锁，控制着不同的区域，它们是互不干扰的。同样，线程获得对象锁的同时，也可以获得该类锁，即同时获得两个锁，这是允许的。

 

到这里，对synchronized的用法已经有了一定的了解。这时有一个疑问，既然有了synchronized修饰方法的同步方式，为什么还需要synchronized修饰同步代码块的方式呢？而这个问题也是synchronized的缺陷所在

 

synchronized的缺陷：当某个线程进入同步方法获得对象锁，那么其他线程访问这里对象的同步方法时，必须等待或者阻塞，这对高并发的系统是致命的，这很容易导致系统的崩溃。如果某个线程在同步方法里面发生了死循环，那么它就永远不会释放这个对象锁，那么其他线程就要永远的等待。这是一个致命的问题。

 

当然同步方法和同步代码块都会有这样的缺陷，只要用了synchronized关键字就会有这样的风险和缺陷。既然避免不了这种缺陷，那么就应该将风险降到最低。这也是同步代码块在某种情况下要优于同步方法的方面。