简述synchronized和java.util.concurrent.locks.Lock的异同

简述synchronized和java.util.concurrent.locks.Lock的异同 
源码来自一篇Java基础题 

主要相同点：Lock能完成synchronized所实现的全部功能 
主要不一样点：Lock有比synchronized更精确的线程语义和更好的性能。synchronized会自动释放锁，而Lock必定要求程序员手工释放，而且必须在finally从句中释放（由于若是不在finally中释放的状况，当抛出异常时，线程直接死掉，可是没有释放锁，使得其余相关线程没法执行。读者能够试试在定义一个数组，并访问越界区，使得程序抛出异常，可是释放锁并未在finally中）。

 

源码例子： 

Java代码 

1. package test.thread;  
2. import java.util.concurrent.locks.Lock;  
3. import java.util.concurrent.locks.ReentrantLock;  
4. public class TestLock {  
5.     private int j;  
6.     private Lock lock = new ReentrantLock();  
7.     public static void main(String[] args) {  
8.         TestLock tt = new TestLock();  
9.         for (int i = 0; i < 2; i++) {  
10.             new Thread(tt.new Adder()).start();  
11.             new Thread(tt.new Subtractor()).start();  
12.         }  
13.     }  
14.     private class Subtractor implements Runnable {  
15.         @Override  
16.         public void run() {  
17.             for (int i = 0; i < 15; i++) {  
18.                 // 这里抛异常了，锁能释放吗？会释放，可是lock就不会释放，因此须要加上try..catch  
19.                 /*synchronized (TestLock.this) {  
20.                     System.out.println("j--=" +j--); 
21.                 }*/  
22.                 lock.lock();  
23.                 try {  
24.                     System.out.println("j--=" + j--);  
25.                 } finally {  
26.                     lock.unlock();  
27.                 }  
28.             }  
29.         }  
30.     }  
31.     private class Adder implements Runnable {  
32.         @Override  
33.         public void run() {  
34.             for (int i = 0; i < 15; i++) {  
35.                  /*synchronized (TestLock.this) { 
36.                      System.out.println("j++="+j++);  
37.                  }*/  
38.                 lock.lock();  
39.                 try {  
40.                     System.out.println("j++=" + j++);  
41.                 } finally {  
42.                     lock.unlock();  
43.                 }  
44.             }  
45.         }  
46.     }  
47. }  

Lock还有更强大的功能，例如，它的tryLock方法能够非阻塞方式去拿锁。 
tryLock() 
tryLock(long timeout, TimeUnit timeUnit) 

trylock()方法：若是获取了锁当即返回true，若是别的线程正持有锁，当即返回false； 

tryLock(long timeout, TimeUnit timeUnit)方法：若是获取了锁定当即返回true，若是别的线程正持有锁，会等待参数给定的时间，在等待的过程当中，若是获取了锁定，就返回true，若是等待超时，返回false； 
是否是比synchronized灵活就体现出来了，好比：你如今正在忙于工做，忽然感受内急，因而你跑向洗手间，到门口发现一个“清洁中，暂停使用”的牌牌。没办法，工做又忙，因此你只好先放弃去洗手间回去忙工做，可能如此反复，终于你发现能够进了，因而...... 
若是用synchronized，当你发现洗手间没法暂时没法进入时，就只能乖乖在门口干等了。 
而使用trylock()呢，首先你试着去洗手间，发现暂时没法进入(trylock返回false)，因而你继续忙你的工做，如此反复，直到能够进入洗手间为止(trylock返回true)。甚至，你很是急，你能够尝试性的在门口等20秒，不行再去忙工做(trylock(20, TimeUnit.SECONDS);)。