Java中Synchronized和Lock的使用和区别

转载自：http://blog.csdn.net/imzoer/article/details/9457639 

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 plain  copy

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. }