Java中Synchronized和Lock的使用

Lock的锁定是通过代码实现的,而 synchronized 是在 JVM 层面上实现的
synchronized在锁定时如果方法块抛出异常,JVM 会自动将锁释放掉,不会因为出了异常没有释放锁造成线程死锁。但是 Lock 的话就享受不到 JVM 带来自动的功能,出现异常时必须在 finally 将锁释放掉,否则将会引起死锁。
在资源竞争不是很激烈的情况下,偶尔会有同步的情形下,synchronized是很合适的。原因在于,编译程序通常会尽可能的进行优化synchronize,另外可读性非常好,不管用没用过5.0多线程包的程序员都能理解。 
ReentrantLock
ReentrantLock提供了多样化的同步,比如有时间限制的同步,可以被Interrupt的同步(synchronized的同步是不能Interrupt的)等。在资源竞争不激烈的情形下,性能稍微比synchronized差点点。但是当同步非常激烈的时候,synchronized的性能一下子能下降好几十倍。而ReentrantLock确还能维持常态。 
Atomic
和上面的类似,不激烈情况下,性能比synchronized略逊,而激烈的时候,也能维持常态。激烈的时候,Atomic的性能会优于ReentrantLock一倍左右。但是其有一个缺点,就是只能同步一个值,一段代码中只能出现一个Atomic的变量,多于一个同步无效。因为他不能在多个Atomic之间同步。 
Lock的使用参见下面的代码(把lock换成synchronized的效果是一样的):
[java] view plaincopy
 
  1. import java.util.concurrent.TimeUnit;  
  2. import java.util.concurrent.locks.Lock;  
  3. import java.util.concurrent.locks.ReentrantLock;  
  4.   
  5. public class Resource3 {  
  6.   
  7.     private Lock lock = new ReentrantLock();  
  8.   
  9.     public void f() {  
  10.   
  11.         // other operations should not be locked...  
  12.   
  13.         System.out.println(Thread.currentThread().getName()  
  14.                 + ":not synchronized in f()");  
  15.         lock.lock();  
  16.         try {  
  17.             for (int i = 0; i < 5; i++) {  
  18.                 System.out.println(Thread.currentThread().getName()  
  19.                         + ":synchronized in f()");  
  20.                 try {  
  21.                     TimeUnit.SECONDS.sleep(3);  
  22.                 } catch (InterruptedException e) {  
  23.                     e.printStackTrace();  
  24.                 }  
  25.             }  
  26.         } finally {  
  27.             lock.unlock();  
  28.         }  
  29.     }  
  30.   
  31.     public void g() {  
  32.   
  33.         // other operations should not be locked...  
  34.         System.out.println(Thread.currentThread().getName()  
  35.                 + ":not synchronized in g()");  
  36.         lock.lock();  
  37.         try {  
  38.             for (int i = 0; i < 5; i++) {  
  39.                 System.out.println(Thread.currentThread().getName()  
  40.                         + ":synchronized in g()");  
  41.                 try {  
  42.                     TimeUnit.SECONDS.sleep(3);  
  43.                 } catch (InterruptedException e) {  
  44.                     e.printStackTrace();  
  45.                 }  
  46.             }  
  47.         } finally {  
  48.             lock.unlock();  
  49.         }  
  50.     }  
  51.   
  52.     public void h() {  
  53.         // other operations should not be locked...  
  54.         System.out.println(Thread.currentThread().getName()  
  55.                 + ":not synchronized in h()");  
  56.         lock.lock();  
  57.         try {  
  58.             for (int i = 0; i < 5; i++) {  
  59.                 System.out.println(Thread.currentThread().getName()  
  60.                         + ":synchronized in h()");  
  61.                 try {  
  62.                     TimeUnit.SECONDS.sleep(3);  
  63.                 } catch (InterruptedException e) {  
  64.                     e.printStackTrace();  
  65.                 }  
  66.             }  
  67.         } finally {  
  68.             lock.unlock();  
  69.         }  
  70.     }  
  71.   
  72.     public static void main(String[] args) {  
  73.   
  74.         final Resource3 rs = new Resource3();  
  75.         new Thread() {  
  76.             public void run() {  
  77.                 rs.f();  
  78.             }  
  79.         }.start();  
  80.         new Thread() {  
  81.             public void run() {  
  82.                 rs.g();  
  83.             }  
  84.         }.start();  
  85.         rs.h();  
  86.     }  
  87. }  
posted @ 2015-12-24 14:47  java高级技术汇  阅读(321)  评论(0编辑  收藏  举报