Java的类锁和对象锁

类锁和对象锁不是同1个东西，一个是类的Class(对应的唯一的一个即这类的二进制字节码)对象的锁，1个是类的实例(！即new出的一个类的对象，一个类会有多个实例对象)的锁。也就是说：1个线程访问静态synchronized的时候，允许另一个线程访问对象的实例synchronized方法。反过来也是成立的，因为他们需要的锁是不同的。

对象锁：Java的所有对象(即new出的一个类的对象，一个类会有多个实例对象)都含有1个互斥锁，这个锁由JVM自动获取和释放。线程进入synchronized方法的时候获取该对象的锁，当然如果已经有线程获取了这个对象的锁，那么当前线程会等待；synchronized方法正常返回或者抛异常而终止，JVM会自动释放对象锁。这里也体现了用synchronized来加锁的1个好处，方法抛异常的时候，锁仍然可以由JVM来自动释放。

类锁：对象锁是用来控制实例方法之间的同步，类锁是用来控制静态方法（或静态变量互斥体）之间的同步。其实类锁只是一个概念上的东西，并不是真实存在的，它只是用来帮助我们理解锁定实例方法和静态方法的区别的。我们都知道，java类可能会有很多个对象，但是只有1个Class对象，也就是说类的不同实例之间共享该类的Class对象。Class对象其实也仅仅是1个java对象，只不过有点特殊而已。由于每个java对象都有1个互斥锁，而类的静态方法是需要Class对象。所以所谓的类锁，不过是Class对象的锁而已。获取类的Class对象有好几种，最简单的就是MyClass.class的方式。

[java] view plain copy

1. /** 
2.  *  
3.  */  
4.   
5. /** 
6.  * 对象锁和类锁的使用 
7.  * <p>Title: MyTest</p> 
8.  * <p>Description: </p> 
9.  * <p>Company: </p> 
10.  * @author 夏 杰 
11.  * @date 2015年12月17日 下午10:45:15 
12.  * @vesion 1.0 
13. */  
14. public class MyLock {  
15.       
16.     /** 
17.      *  对象锁：形式1 
18.      *  synchroined 修饰方法 直接方法名，对应的是当前类的new出来对象实例的实例硕 
19.      */  
20.     public synchronized void objLockMethod1()  
21.     {  
22.         System.out.println("in...objLockMethod1");  
23.         try  
24.         {  
25.             Thread.sleep(500);  
26.         } catch (InterruptedException e)  
27.         {  
28.             e.printStackTrace();  
29.         }  
30.         System.out.println("out...objLockMethod1");  
31.     }  
32.   
33.       
34.         /** 
35.          * 对象锁：形式2 
36.          * synchonced(this) 修饰代码块 ,this代表的是当前类的实例对象锁 
37.          */  
38.         public void objLockMethod2()  
39.         {  
40.             synchronized (this)  
41.             {  
42.                 System.out.println("in...objLockMethod2");  
43.                 try  
44.                 {  
45.                     Thread.sleep(500);  
46.                 } catch (InterruptedException e)  
47.                 {  
48.                     e.printStackTrace();  
49.                 }  
50.                 System.out.println("out...objLockMethod2");  
51.             }  
52.   
53.         }  
54.       
55.   
56.         /** 
57.          * 类锁：形式1 
58.          * static 类 用synchronized修饰 对应的是该类对应的Class类对象，只有唯一的一个 
59.          */  
60.         public static synchronized void classLock1()  
61.         {  
62.             System.out.println("classLock1------in");  
63.             try  
64.             {  
65.                 Thread.sleep(500);  
66.             } catch (InterruptedException e)  
67.             {  
68.                 e.printStackTrace();  
69.             }  
70.             System.out.println("classLock1------out");  
71.         }  
72.           
73.           
74.         /** 
75.          * 类锁：形式2 
76.          * synchronized (MyLock.class)  
77.          * synchronized中的锁使用 本类名.class 对应的是该类对应的Class类对象，只有唯一的一个 
78.          */  
79.         public static  void classLock2()  
80.         {  
81.             synchronized (MyTest.class) {  
82.                 System.out.println("classLock2------in");  
83.                 try  
84.                 {  
85.                     Thread.sleep(500);  
86.                 } catch (InterruptedException e)  
87.                 {  
88.                     e.printStackTrace();  
89.                 }  
90.                 System.out.println("classLock2------out");  
91.             }  
92.               
93.         }  
94.       
95.   
96. }  

对象锁和类锁的测试

[java] view plain copy

1. /** 
2.  *  
3.  */  
4.   
5. /** 
6.  * <p>Title: Thread1</p> 
7.  * <p>Description: </p> 
8.  * <p>Company: </p> 
9.  * @author 夏 杰 
10.  * @date 2015年12月17日 下午11:20:40 
11.  * @vesion 1.0 
12. */  
13. public class Thread1 implements Runnable{  
14.       
15.     MyLock myLock ;  
16.   
17.     public Thread1(MyLock myLock) {  
18.         this.myLock = myLock;  
19.     }  
20.   
21.       
22.     @Override  
23.     public void run() {  
24.           
25.         myLock.classLock1();  
26.     }  
27.   
28. }  

[java] view plain copy

1. /** 
2.  *  
3.  */  
4.   
5. /** 
6.  * <p>Title: Thread1</p> 
7.  * <p>Description: </p> 
8.  * <p>Company: </p> 
9.  * @author 夏 杰 
10.  * @date 2015年12月17日 下午11:20:40 
11.  * @vesion 1.0 
12. */  
13. public class Thread2 implements Runnable{  
14.       
15.     MyLock myLock ;  
16.   
17.     public Thread2(MyLock myLock) {  
18.         this.myLock = myLock;  
19.     }  
20.   
21.     @Override  
22.     public void run() {  
23.           
24.         myLock.objLockMethod1();  
25.     }  
26.   
27. }  

[java] view plain copy

1. /** 
2.  *  
3.  */  
4.   
5. /** 
6.  * <p>Title: ThreadMain</p> 
7.  * <p>Description: </p> 
8.  * <p>Company: </p> 
9.  * @author 夏 杰 
10.  * @date 2015年12月17日 下午11:27:05 
11.  * @vesion 1.0 
12. */  
13. public class ThreadMain {  
14.   
15.     /** 
16.      * @param args 
17.      */  
18.     public static void main(String[] args) {  
19.           
20.       MyLock myLock = new MyLock();  
21.       new Thread(new Thread1(myLock)).start();  
22.       new Thread(new Thread2(myLock)).start();  
23.         
24.     }  
25.   
26. }  

    可以看出，类锁和对象锁不是同1个东西，一个是类的Class对象的锁，1个是类的实例的锁。也就是说：1个线程访问静态synchronized的时候，允许另一个线程访问对象的实例synchronized方法。反过来也是成立的，因为他们需要的锁是不同的。