synchronized和java.util.concurrent.locks.Lock的异同
synchronized和java.util.concurrent.locks.Lock的异同 ？
主要相同点：Lock能完成synchronized所实现的所有功能
主要不同点：Lock有比synchronized更精确的线程语义和更好的性能。synchronized会自动释放锁，而Lock一定要求程序员手工释放，并且必须在finally从句中释放。Lock还有更强大的功能，例如，它的tryLock方法可以非阻塞方式去拿锁。
举例说明（对下面的题用lock进行了改写）：

[java] view plaincopyprint?
01.package com.huawei.interview; 
02.import java.util.concurrent.locks.Lock; 
03.import java.util.concurrent.locks.ReentrantLock; 
04. 
05.public class ThreadTest { 
06.    private int j; 
07.    private Lock lock = new ReentrantLock(); 
08.    public static void main(String[] args) { 
09.        // TODO Auto-generated method stub  
10.        ThreadTest tt = new ThreadTest(); 
11.        for(int i=0;i<2;i++) 
12.        { 
13.            new Thread(tt.new Adder()).start(); 
14.            new Thread(tt.new Subtractor()).start(); 
15.        } 
16.    } 
17.    private class Subtractor implements Runnable 
18.    { 
19. 
20.        @Override 
21.        public void run() { 
22.            // TODO Auto-generated method stub  
23.            while(true) 
24.            { 
25.                /*synchronized (ThreadTest.this) {          
26.                    System.out.println("j--=" + j--);
27.                    //这里抛异常了，锁能释放吗？
28.                }*/ 
29.                lock.lock(); 
30.                try 
31.                { 
32.                    System.out.println("j--=" + j--); 
33.                }finally 
34.                { 
35.                    lock.unlock(); 
36.                } 
37.            } 
38.        }    
39.    } 
40.    private class Adder implements Runnable 
41.    { 
42.        @Override 
43.        public void run() { 
44.            // TODO Auto-generated method stub  
45.            while(true) 
46.            { 
47.                /*synchronized (ThreadTest.this) {
48.                System.out.println("j++=" + j++);   
49.                }*/ 
50.                lock.lock(); 
51.                try 
52.                { 
53.                    System.out.println("j++=" + j++); 
54.                }finally 
55.                { 
56.                    lock.unlock(); 
57.                }                
58.            }            
59.        }    
60.    } 
61.}