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的效果是一样的）：

1. import java.util.concurrent.TimeUnit;
2. import java.util.concurrent.locks.Lock;
3. import java.util.concurrent.locks.ReentrantLock;
4. public class Resource3 {
5. private Lock lock = new ReentrantLock();
6. public void f() {
7. // other operations should not be locked...
8. System.out.println(Thread.currentThread().getName()
9. + ":not synchronized in f()");
10. lock.lock();
11. try {
12. for (int i = 0; i < 5; i++) {
13. System.out.println(Thread.currentThread().getName()
14. + ":synchronized in f()");
15. try {
16. TimeUnit.SECONDS.sleep(3);
17. } catch (InterruptedException e) {
18. e.printStackTrace();
19. }
20. }
21. } finally {
22. lock.unlock();
23. }
24. }
25. public void g() {
26. // other operations should not be locked...
27. System.out.println(Thread.currentThread().getName()
28. + ":not synchronized in g()");
29. lock.lock();
30. try {
31. for (int i = 0; i < 5; i++) {
32. System.out.println(Thread.currentThread().getName()
33. + ":synchronized in g()");
34. try {
35. TimeUnit.SECONDS.sleep(3);
36. } catch (InterruptedException e) {
37. e.printStackTrace();
38. }
39. }
40. } finally {
41. lock.unlock();
42. }
43. }
44. public void h() {
45. // other operations should not be locked...
46. System.out.println(Thread.currentThread().getName()
47. + ":not synchronized in h()");
48. lock.lock();
49. try {
50. for (int i = 0; i < 5; i++) {
51. System.out.println(Thread.currentThread().getName()
52. + ":synchronized in h()");
53. try {
54. TimeUnit.SECONDS.sleep(3);
55. } catch (InterruptedException e) {
56. e.printStackTrace();
57. }
58. }
59. } finally {
60. lock.unlock();
61. }
62. }
63. public static void main(String[] args) {
64. final Resource3 rs = new Resource3();
65. new Thread() {
66. public void run() {
67. rs.f();
68. }
69. }.start();
70. new Thread() {
71. public void run() {
72. rs.g();
73. }
74. }.start();
75. rs.h();
76. }
77. }