主要相同点：Lock能完成synchronized所实现的所有功能

主要不同点：Lock有比synchronized更精确的线程语义和更好的性能。synchronized会自动释放锁，而Lock一定要求程序员手工释放，并且必须在finally从句中释放。Lock还有更强大的功能，例如，它的tryLock方法可以非阻塞方式去拿锁。

举例说明（对下面的题用lock进行了改写）：

1. package com.huawei.interview;
   
2. 
   
3. 
   
4. 
   
5. import java.util.concurrent.locks.Lock;
   
6. 
   
7. import java.util.concurrent.locks.ReentrantLock;
   
8. 
   
9. 
   
10. 
    
11. public class ThreadTest {
    
12. 
    
13. 
    
14. 
    
15.     /**
    
16. 
    
17.      * @param args
    
18. 
    
19.      */
    
20. 
    
21.    
    
22. 
    
23.     private int j;
    
24. 
    
25.     private Lock lock = new ReentrantLock();
    
26. 
    
27.     public static void main(String[] args) {
    
28. 
    
29.        // TODO Auto-generated method stub
    
30. 
    
31.        ThreadTest tt = new ThreadTest();
    
32. 
    
33.        for(int i=0;i<2;i++)
    
34. 
    
35.        {
    
36. 
    
37.            new Thread(tt.new Adder()).start();
    
38. 
    
39.            new Thread(tt.new Subtractor()).start();
    
40. 
    
41.        }
    
42. 
    
43.     }
    
44. 
    
45. 
    
46. 
    
47.     private class Subtractor implements Runnable
    
48. 
    
49.     {
    
50. 
    
51. 
    
52. 
    
53.        @Override
    
54. 
    
55.        public void run() {
    
56. 
    
57.            // TODO Auto-generated method stub
    
58. 
    
59.            while(true)
    
60. 
    
61.            {
    
62. 
    
63.               /*synchronized (ThreadTest.this) {      
    
64. 
    
65.                   System.out.println("j--=" + j--);
    
66. 
    
67.                   //这里抛异常了，锁能释放吗？
    
68. 
    
69.               }*/
    
70. 
    
71.               lock.lock();
    
72. 
    
73.               try
    
74. 
    
75.               {
    
76. 
    
77.                   System.out.println("j--=" + j--);
    
78. 
    
79.               }finally
    
80. 
    
81.               {
    
82. 
    
83.                   lock.unlock();
    
84. 
    
85.               }
    
86. 
    
87.            }
    
88. 
    
89.         }
    
90. 
    
91.       
    
92. 
    
93.     }
    
94. 
    
95.    
    
96. 
    
97.     private class Adder implements Runnable
    
98. 
    
99.     {
    
100. 
     
101. 
     
102. 
     
103.        @Override
     
104. 
     
105.        public void run() {
     
106. 
     
107.            // TODO Auto-generated method stub
     
108. 
     
109.            while(true)
     
110. 
     
111.            {
     
112. 
     
113.               /*synchronized (ThreadTest.this) {
     
114. 
     
115.               System.out.println("j++=" + j++);
     
116. 
     
117.               }*/
     
118. 
     
119.               lock.lock();
     
120. 
     
121.               try
     
122. 
     
123.               {
     
124. 
     
125.                   System.out.println("j++=" + j++);
     
126. 
     
127.               }finally
     
128. 
     
129.               {
     
130. 
     
131.                   lock.unlock();
     
132. 
     
133.               }            
     
134. 
     
135.            }         
     
136. 
     
137.        }
     
138. 
     
139.       
     
140. 
     
141.     }
     
142. 
     
143. }
     
144. 
     

复制代码

顶一个！！！！！