一、ReenTrantLock可重入锁 与synchronized 同步锁的区别
- 锁的实现
synchronized是Java中的关键字，是依赖于JVM实现的，Java 虚拟机团队在 JDK1.6 为 synchronized 关键字进行了很多的优化，但这些优化都是在虚拟机层面实现的，并没有直接暴露给我们。而ReenTrantLock是JDK API 实现的，有直接的源码可供阅读。ReenTrantLock可以知道线程有没有成功获取到锁。这个是synchronized无法办到的。
- 可重入性
两者都是可重入锁。两者都是同一个线程没进入一次，锁的计数器都自增1，所以要等到锁的计数器下降为0时才能释放锁。
- 锁释放的区别
很明显Synchronized的使用比较方便简洁，并且由编译器去保证锁的加锁和释放，在代码执行时出现异常，JVM会自动释放锁定，因此不会导致死锁现象发生。而ReenTrantLock需要手工声明来加锁和释放锁，为了避免忘记手工释放锁造成死锁，就必须将 unLock()放到finally{} 中。
- 性能的区别
相比 synchronized，ReentrantLock 增加了一些高级功能。主要有：① 等待可中断；② 可实现公平锁；③ 可实现选择性通知（锁可以绑定多个条件）：
1）ReentrantLock 提供了一种能够中断等待锁线程的机制，通过 lock.lockInterruptibly() 来实现这个机制，也就是说正在等待的线程可以选择放弃等待，改为处理其他事情；
2）ReentrantLock 可以指定是公平锁还是非公平，而 synchronized 只能是非公平锁。所谓的公平锁，就是先等待的线程最先获得锁；ReentrantLock 默认是非公平的，可以通过 ReentrantLock 类的 ReentrantLock(boolean fair) 构造方法来制定是否是公平的；
3）synchronized 关键字结合 wait() 和 notify()/notifyAll() 方法使用，可以实现等待/通知机制，ReentrantLock 类则需要借助于 Condition 接口与 newCondition() 方法。
在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。所以说，在具体使用时要根据适当情况选择。
举个例子：当有多个线程读写文件时，读操作和写操作会发生冲突现象，写操作和写操作会发生冲突现象，但是读操作和读操作不会发生冲突现象。但是采用synchronized关键字来实现同步的话，就会导致一个问题：
如果多个线程都只是进行读操作，所以当一个线程在进行读操作时，其他线程只能等待无法进行读操作。
因此就需要一种机制来使得多个线程都只是进行读操作时，线程之间不会发生冲突，通过Lock就可以办到。
二、ReentrantLock获取锁的三种方式
ReentrantLock，意思是“可重入锁”,即：自己可以再次获取自己的内部锁。比如，一个线程获得了某个对象的锁，此时这个对象锁还没有释放，当其再次想要获取这个对象的锁时，还可以再获取的；如果不可锁重入的话，就会造成死锁；同一个线程每次获取锁，锁的计数器都自增1，所以要等到锁的计数器下降为0时，才能最终释放锁。
ReentrantLock是唯一实现了Lock接口的类，并且ReentrantLock提供了更多的方法。如：
1）lock()， 如果获取了锁立即返回，如果别的线程持有锁，当前线程则一直处于休眠状态，直到获取锁
2）tryLock()，如果获取了锁立即返回true，如果别的线程正持有锁，立即返回false；
3）tryLock(long timeout,TimeUnit unit)， 如果获取了锁定立即返回true，如果别的线程正持有锁，会等待参数给定的时间，在等待的过程中，如果获取了锁定，就返回true，如果等待超时，返回false；
4） lockInterruptibly:如果获取了锁定立即返回，如果没有获取锁定，当前线程处于休眠状态，直到或者锁定，或者当前线程被别的线程中断。
下面来逐个介绍Lock接口中每个方法的使用，lock()、tryLock()、tryLock(long time, TimeUnit unit)和lockInterruptibly()是用来获取锁的。unLock()方法是用来释放锁的。
首先lock()方法，是平常使用得最多的一个方法，就是用来获取锁。如果锁已被其他线程获取，则进行等待。必须主动去释放锁，并且在发生异常时，不会自动释放锁。因此，使用Lock必须在try{}catch{}块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被被释放，防止死锁的发生。通常使用Lock来进行同步的话，是以下面这种形式去使用的：
Lock lock = ...;
lock.lock();
try{
//处理任务
}catch(Exception ex){
}finally{
lock.unlock(); //释放锁
}
tryLock()方法，是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true；如果获取失败（即锁已被其他线程获取），则返回false，也就说这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。
tryLock(long time, TimeUnit unit)方法和tryLock()方法是类似的，只不过区别在于这个方法在拿不到锁时会等待一定的时间，在时间期限之内如果还拿不到锁，就返回false。如果如果一开始拿到锁或者在等待期间内拿到了锁，则返回true。
所以，一般情况下通过tryLock来获取锁时是这样使用的：
Lock lock = ...;
if(lock.tryLock()) {
try{
//处理任务
}catch(Exception ex){
}finally{
lock.unlock(); //释放锁
}
}else {
//如果不能获取锁，则直接做其他事情
}
lockInterruptibly()方法，获取锁时，如果线程正在等待获取锁，则这个线程能够响应中断，即中断线程的等待状态。即，当两个线程同时通过lock.lockInterruptibly()想获取某个锁时，假若此时线程A获取到了锁，而线程B只有在等待，那么对线程B调用threadB.interrupt()方法能够中断线程B的等待过程。
由于lockInterruptibly()的声明中抛出了异常，所以lock.lockInterruptibly()必须放在try块中或者在调用lockInterruptibly()的方法外声明抛出InterruptedException。
lockInterruptibly()一般的使用形式如下：
public void method() throws InterruptedException {
lock.lockInterruptibly();
try {
//.....
}
finally {
lock.unlock();
}
}
注意，当一个线程获取了锁之后，是不会被interrupt()方法中断的。
因此当通过lockInterruptibly()方法获取某个锁时，如果不能获取到，只有进行等待的情况下，是可以响应中断的。
而用synchronized修饰的话，当一个线程处于等待某个锁的状态，是无法被中断的，只有一直等待下去。
三、ReentrantLock的具体使用
下面通过一些实例看具体看一下如何使用ReentrantLock。
例子1，lock()的正确使用方法
import java.util.*;
import java.util.concurrent.locks.*;
public class Test {
private ArrayList<Integer> arrayList = new ArrayList<Integer>();
public static void main(String[] args) {
final Test test = new Test();
new Thread(){
public void run() {
test.insert(Thread.currentThread());
};
}.start();
new Thread(){
public void run() {
test.insert(Thread.currentThread());
};
}.start();
}
public void insert(Thread thread) {
Lock lock = new ReentrantLock(); //注意这个地方
lock.lock();
try {
System.out.println(thread.getName()+" ---------- get lock");
for(int i=0;i<5;i++) {
arrayList.add(i);
}
} catch (Exception e) {
// TODO: handle exception
}finally {
System.out.println(thread.getName()+" ---------- release lock");
lock.unlock();
}
}
}
多运行几次，每次输出的结果不一样，其中一次输出：
怎么会输出这个结果？第二个线程怎么会在第一个线程释放锁之前得到了锁？原因在于，在insert方法中的lock变量是局部变量，每个线程执行该方法时都会保存一个副本，那么理所当然每个线程执行到lock.lock()处获取的是不同的锁，所以就不会发生冲突。
知道了原因改起来就比较容易了，只需要将lock声明为类的属性即可。
import java.util.*;
import java.util.concurrent.locks.*;
public class Test1 {
private ArrayList<Integer> arrayList = new ArrayList<Integer>();
private Lock lock = new ReentrantLock(); //注意这个地方
public static void main(String[] args) {
final Test test = new Test();
new Thread(){
public void run() {
test.insert(Thread.currentThread());
};
}.start();
new Thread(){
public void run() {
test.insert(Thread.currentThread());
};
}.start();
}
public void insert(Thread thread) {
lock.lock();
try {
System.out.println(thread.getName()+" ---------- get lock");
for(int i=0;i<5;i++) {
arrayList.add(i);
}
} catch (Exception e) {
// TODO: handle exception
}finally {
System.out.println(thread.getName()+" ---------- release lock");
lock.unlock();
}
}
}
多运行几次，每次输出的结果不一样，其中一次输出：
这样就是正确地使用Lock的方法了。
例子2，tryLock()的使用方法
import java.util.*;
import java.util.concurrent.locks.*;
public class TryLockTest {
private ArrayList<Integer> arrayList = new ArrayList<Integer>();
private Lock lock = new ReentrantLock(); //注意这个地方
public static void main(String[] args) {
final Test test = new Test();
new Thread(){
public void run() {
test.insert(Thread.currentThread());
};
}.start();
new Thread(){
public void run() {
test.insert(Thread.currentThread());
};
}.start();
}
public void insert(Thread thread) {
if(lock.tryLock()) {
try {
System.out.println(thread.getName()+" ---------- get lock");
for(int i=0;i<5;i++) {
arrayList.add(i);
}
} catch (Exception e) {
// TODO: handle exception
}finally {
System.out.println(thread.getName()+" ---------- release lock");
lock.unlock();
}
} else {
System.out.println(thread.getName()+" ---------- get lock failed");
}
}
}
多运行几次，每次输出的结果不一样：
例子3，lockInterruptibly()响应中断的使用方法：
import java.util.*;
import java.util.concurrent.locks.*;
public class LockInterruptiblyTest {
private Lock lock = new ReentrantLock();
public static void main(String[] args) {
LockInterruptiblyTest test = new LockInterruptiblyTest();
MyThread thread1 = new MyThread(test);
MyThread thread2 = new MyThread(test);
thread1.start();
thread2.start();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
thread2.interrupt();
}
public void insert(Thread thread) throws InterruptedException{
lock.lockInterruptibly(); //注意，如果需要正确中断等待锁的线程，必须将获取锁放在外面，然后将InterruptedException抛出
try {
System.out.println(thread.getName()+" ---------- get lock");
long startTime = System.currentTimeMillis();
for( ; ;) {
if(System.currentTimeMillis() - startTime >= Integer.MAX_VALUE)
break;
//插入数据
}
}
finally {
System.out.println(Thread.currentThread().getName()+"execute finally");
lock.unlock();
System.out.println(thread.getName()+" ---------- release lock");
}
}
}
class MyThread extends Thread {
private LockInterruptiblyTest test = null;
public MyThread(LockInterruptiblyTest test) {
this.test = test;
}
@Override
public void run() {
try {
test.insert(Thread.currentThread());
} catch (InterruptedException e) {
System.out.println(Thread.currentThread().getName()+"----------interrupt");
}
}
}
运行之后，发现thread2能够被正确中断。
输出结果：
