java 对象锁和类锁的区别(转)

java 对象锁和类锁的区别   转自 <http://zhh9106.iteye.com/blog/2151791>

在java编程中,经常需要用到同步,而用得最多的也许是synchronized关键字了,下面看看这个关键字的用法。

因为synchronized关键字涉及到锁的概念,所以先来了解一些相关的锁知识。

 

java的内置锁:每个java对象都可以用做一个实现同步的锁,这些锁成为内置锁。线程进入同步代码块或方法的时候会自动获得该锁,在退出同步代码块或方法时会释放该锁。获得内置锁的唯一途径就是进入这个锁的保护的同步代码块或方法。

 

java内置锁是一个互斥锁,这就是意味着最多只有一个线程能够获得该锁,当线程A尝试去获得线程B持有的内置锁时,线程A必须等待或者阻塞,知道线程B释放这个锁,如果B线程不释放这个锁,那么A线程将永远等待下去。

 

java的对象锁和类锁:java的对象锁和类锁在锁的概念上基本上和内置锁是一致的,但是,两个锁实际是有很大的区别的,对象锁是用于对象实例方法,或者一个对象实例上的,类锁是用于类的静态方法或者一个类的class对象上的。我们知道,类的对象实例可以有很多个,但是每个类只有一个class对象,所以不同对象实例的对象锁是互不干扰的,但是每个类只有一个类锁。但是有一点必须注意的是,其实类锁只是一个概念上的东西,并不是真实存在的,它只是用来帮助我们理解锁定实例方法和静态方法的区别的

 

上面已经对锁的一些概念有了一点了解,下面探讨synchronized关键字的用法。

 

synchronized的用法:synchronized修饰方法和synchronized修饰代码块。

 

下面分别分析这两种用法在对象锁和类锁上的效果。

 

对象锁的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关键字就会有这样的风险和缺陷。既然避免不了这种缺陷,那么就应该将风险降到最低。这也是同步代码块在某种情况下要优于同步方法的方面。例如在某个类的方法里面:这个类里面声明了一个对象实例,SynObject so=new SynObject();在某个方法里面调用了这个实例的方法so.testsy();但是调用这个方法需要进行同步,不能同时有多个线程同时执行调用这个方法。

这时如果直接用synchronized修饰调用了so.testsy();代码的方法,那么当某个线程进入了这个方法之后,这个对象其他同步方法都不能给其他线程访问了。假如这个方法需要执行的时间很长,那么其他线程会一直阻塞,影响到系统的性能。

如果这时用synchronized来修饰代码块:synchronized(so){so.testsy();},那么这个方法加锁的对象是so这个对象,跟执行这行代码的对象没有关系,当一个线程执行这个方法时,这对其他同步方法时没有影响的,因为他们持有的锁都完全不一样。

 

不过这里还有一种特例,就是上面演示的第一个例子,对象锁synchronized同时修饰方法和代码块,这时也可以体现到同步代码块的优越性,如果test1方法同步代码块后面有非常多没有同步的代码,而且有一个100000的循环,这导致test1方法会执行时间非常长,那么如果直接用synchronized修饰方法,那么在方法没执行完之前,其他线程是不可以访问test2方法的,但是如果用了同步代码块,那么当退出代码块时就已经释放了对象锁,当线程还在执行test1的那个100000的循环时,其他线程就已经可以访问test2方法了。这就让阻塞的机会或者线程更少。让系统的性能更优越。

 

一个类的对象锁和另一个类的对象锁是没有关联的,当一个线程获得A类的对象锁时,它同时也可以获得B类的对象锁。

来源: <http://zhh9106.iteye.com/blog/2151791>
 

来自为知笔记(Wiz)

    原文作者:renhq
    原文地址: http://www.cnblogs.com/renhq/p/4666640.html
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞