我们常用的synchronized关键字是一种最简单的线程同步控制方法，它决定了一个线程是否可以访问临界区资源。同时Object.wait() 和Object.notify()方法起到了线程等待和通知的作用。这些工具对于实现复杂的多线程协作起到了重要的作用。
这里，我们介绍一种synchronized，Object.wait() 和Object.notify()方法的替代品--重入锁。首先看下重入锁的例子：
public ReentrantLock lock = new ReentrantLock();//声明一把重入锁
......
lock.lock();//开始加锁
doSomething();//需要同步的代码块
lock.unlock();//释放锁
从上述代码可以看出，与synchronized相比，重入锁有着显式的操作过程，开发人员需要手动加锁，释放锁。因此，重入锁对逻辑控制的灵活性要远远高于synchronized，但是，在退出临界区时，必须记得释放锁，否则其它线程再也无法访问临界区资源了。
之所以叫重入锁，是因为这种锁是可以反复进入的（当然仅仅局限于同一个线程），例如下面的形式也是可以的：
lock.lock();//开始加锁
lock.lock();
doSomething();//需要同步的代码块
lock.unlock();//释放锁
lock.unlock();
一个线程连续多次获得同一把锁，是允许的，否则的话，同一个线程在第二次获得锁时，会和自己产生死锁。
但是需要注意的是，如果同一个线程多次获得锁，释放锁的时候必须释放相同次数的锁。如果释放少了，其它线程无法进入临界区，如果释放多了，则会抛出IllegalMonitorStateException异常。
除了使用上的灵活性外，重入锁还提供了一些高级功能，如中断响应、限时等待、公平锁等功能。
中断响应：
对于synchronized，如果一个线程在等待锁，结果要么它获得这把锁执行其任务，要么就一直等待锁。而使用重入锁，就有了另一种选择，那就是线程可以被中断，即线程在等待锁的过程中，程序可以根据需求取消对锁的请求。中断正是提供了这种机制，使程序在等待锁时，依然能够收到通知，被告知无需继续等待，这种情况对于处理死锁是有很大帮助的。
下面模拟一段死锁，并通过中断解决这个死锁：
//声明两把重入锁
public ReentrantLock lock1 = new ReentrantLock();
public ReentrantLock lock2 = new ReentrantLock();
class MyThread implements Runnable(){
private int lock;
public MyThread (int lock){
this.lock = lock;
}
@Override
public void run(){
if(lock == 1){
lock1.lockInterruptibly();//申请锁1，如果要使用中断功能，需使用lockInterruptibly()申请锁
Thread.sleep(5000);
lock2.lockInterruptibly();//申请锁2
}else{
lock2.lockInterruptibly();//申请锁2
Thread.sleep(5000);
lock1.lockInterruptibly();//申请锁1
}
lock1.unlock();//释放锁
lock2.unlock();
}
}
public static void main(String[] s){
//t1先请求锁1,再请求锁2
//t2先请求锁2,再请求锁1
//这样两个线程就会互相等待对方，造成死锁
Thread t1 = new Thread(new MyThread(1));
Thread t2 = new Thread(new MyThread(2));
t1.start();
t2.start();
//上面两个线程已经形成死锁
Thread.sleep(1000);
t2.interrupt();//中断T2，放弃对锁的请求，并释放持有的锁
}
限时等待：
除了等待外部通知外，要避免死锁还有一种方法，那就是限时等待。给定一个等待时间，如果在这个超出这个时间，线程还没获得锁，则放弃等待。我们可以使用tryLock()方法进行一次限时等待，如lock.tryLock(5,TimeUnit.SECONDS)表示设置5秒的等待时长，如果超过5s还未得到锁，则返回false。
if(lock.tryLock(5,TimeUnit.SECONDS)){
doSomething();
}else{
System.out.println("没有获得锁，你滚吧。");
}
tryLock()方法也可以不带参数运行，这种情况下，线程会请求锁，如果请求不到，立即返回false，无需等待，也不会产生死锁。
公平锁：
大多数情况下，锁的申请是非公平的，即先等待的线程不一定先获得锁，对排队等待锁的线程来说是不公平的。而公平的锁，就会按照先来后到的顺序分配锁。公平锁的一大特点就是，它不会产生饥饿现象。只要你排队，最终还是可以等到资源的。
如果我们使用synchronized关键字，那么产生的锁就是非公平的，而重入锁允许我们对其公平性进行设置，它提供了一个构造函数：
public ReentrantLock(boolean fair)
当fair为true时，表示锁是公平的。虽然公平锁很优美，但是要实现公平锁必然要维护一个有序队列，因此公平锁的实现成本较高，性能相对也比较低下，因此，默认情况下，锁是非公平的。
总结：
ReentrantLock有几个重要的方法：
1. lock()：获得锁，如果锁被占用，则等待
2. lockInterruptibly()：获得锁，但优先响应中断
3. tryLock()：尝试获得锁，并制定等待时间，超时返回false
4. unlock()：释放锁
参考资料：
《java高并发程序设计》