【概述】
重入锁可以完全代替synchronized关键字。
与synchronized相比，重入锁ReentrantLock有着显示的操作过程，即开发人员必须手动指定何时加锁，何时释放锁，所以重入锁对于逻辑控制的灵活性好于synchronized。
要注意的是，每次在退出临界区时，必须记得释放锁，否则其他线程将没有机会访问临界区了。
【ReentrantLock入门例子】
package com.higgin.reentrantLock; import java.util.concurrent.locks.ReentrantLock; /**
* Created by HigginCui on 2017/5/15.
*/
public class ReentrantLockThread implements Runnable{ public static ReentrantLock lock = new ReentrantLock(); //实例化一个重入锁 public static int num = 0; @Override
public void run() {
for(int i =0; i<100; i++){
lock.lock(); //上锁
try{
num++;
}finally {
lock.unlock(); //释放锁
}
}
} public static void main(String[] args) throws InterruptedException{
ReentrantLockThread rlThread = new ReentrantLockThread();
Thread t1 = new Thread(rlThread);
Thread t2 = new Thread(rlThread); t1.start();
t2.start(); t1.join();
t2.join(); System.out.println(num);
}
}
【运行结果】
【为什么叫重入锁】
对于一个线程，这种锁是可以重复进入的。一个线程可以两次获得同一个锁。
有一点要注意，如果一个线程多次获得锁，那么释放锁必须有相同的次数。
如果释放锁的次数多了，会抛出一个java.lang.IllegalMonitorStateException异常。
如果释放锁的次数少了，相当于还持有这个锁，其他线程无法进入临界区。
lock.lock();
lock.lock(); //一个线程可以多次获得同一个锁
try{
num++;
}finally {
lock.unlock();
lock.unlock(); //锁必须释放相同的次数
}
【ReentrantLock的几个重要方法】
1.lock()：获得锁，如果锁被占用，则等待。
2.lockInterruptibly()：获得锁，但会优先响应中断。
3.tryLock()：尝试获得锁，返回true/false，该方法不等待，立即返回。
4.tryLock(long time, Timeunit unit)：在给定的时间内尝试获得锁。
5.unlock()：释放锁。
【中断响应】
对于synchronized来说，如果一个线程在等待wait，那么结果只有两种情况：1.获得这把锁继续执行；2.继续保持等待。
对于重入锁，提供了第3种可能：3.线程还可以被中断。
【利用重入锁的中断响应来中断结束线程，解决死锁问题】
package com.higgin.reentrantLock; import java.util.concurrent.locks.ReentrantLock; /**
* Created by HigginCui on 2017/5/16.
*/
public class DeadLockThread implements Runnable{ public static ReentrantLock lock1 = new ReentrantLock(); public static ReentrantLock lock2 = new ReentrantLock(); boolean flag; public DeadLockThread(boolean flag){
this.flag = flag;
} @Override
public void run() {
try {
if (flag == false) {
lock1.lockInterruptibly(); //获得lock1锁，优先响应中断，即在等待的过程中，可以响应中断
Thread.sleep();
lock2.lockInterruptibly();
} else {
lock2.lockInterruptibly(); //获得lcok2锁,优先响应中断，顺序与上面的相反
Thread.sleep();
lock1.lockInterruptibly();
}
} catch (InterruptedException e) {
// e.printStackTrace();
System.out.println(Thread.currentThread().getName()+"被中断啦！");
} finally {
if (lock1.isHeldByCurrentThread()) { //判断当前线程是否持有lock1锁
lock1.unlock(); //如果持有lock1锁，就释放
}
if(lock2.isHeldByCurrentThread()){ //再判断当前线程是否持有lock2锁，如果持有就释放
lock2.unlock();
}
System.out.println(Thread.currentThread().getName()+"线程退出啦！！");
}
} public static void main(String[] args) throws InterruptedException{
DeadLockThread d1 = new DeadLockThread(true);
DeadLockThread d2 = new DeadLockThread(false); Thread t1 = new Thread(d1,"t1");
Thread t2 = new Thread(d2,"t2"); t1.start();
t2.start(); //同时启动这两个线程，必定会产生死锁 Thread.sleep(); //main线程延时5秒
t2.interrupt(); //为t2线程产生一个中断，如果没有这个中断，两个线程都会处于死锁状态，都在等待对方释放锁
}
}
【运行结果】
【分析】
线程t1启动了，然后启动t2，
t1先占用lock1,等待500ms，
t2先占用lock2,等待500ms,
t1在500ms等待结束后，想获得lock2，但此时lock2已经被t2占用，
反之t2在500ms等待结束后，想获得lock1，但此时lcok1又被t1占用，
于是陷入了死锁状态。
由于lock.lcokInterruptibly()是一个可以对中断进行相应的锁申请动作，在线程等待的过程中，可以响应中断。
main线程在5000ms后中断了t2线程，那么t2会进入catch捕获异常，打印相关的异常信息，然后进入finally代码块释放当前线程t2持有的锁lock2，t2退出。
此时t1就可以获得t2释放的lock2,然后也进入finally代码块，释放其持有的两个锁lock1和lock2。
【申请锁设置等待时间tryLock(10,TimeUnit.SECONDS)】
这也是避免死锁的一种方法，即申请锁限时等待，给定一个等待时间，如果线程在这段时间内无法申请获得锁，那么线程会自动放弃。
【tryLock(long time, Timeunit unit)的例子】
package com.higgin.reentrantLock; import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock; /**
* Created by HigginCui on 2017/5/17.
*/
public class TimeLockThread implements Runnable { ReentrantLock lock = new ReentrantLock(); @Override
public void run() {
try{
if (lock.tryLock(, TimeUnit.SECONDS)){ //如果当前线程5秒内无法获得对应的锁，那么其会自动释放锁
System.out.println(Thread.currentThread().getName()+"获得锁，并占用6秒！");
Thread.sleep(); //一旦获得锁，那么回占用锁的时间为6秒
}
}catch (InterruptedException e){
e.printStackTrace();
}finally {
if(lock.isHeldByCurrentThread()){
System.out.println(Thread.currentThread().getName()+"释放锁啦，然后退出！");
lock.unlock();
}else{
System.out.println(Thread.currentThread().getName()+"没有占用锁，直接退出！");
}
}
} public static void main(String[] args) {
TimeLockThread tt = new TimeLockThread();
Thread t1 = new Thread(tt,"t1");
Thread t2 = new Thread(tt,"t2"); t1.start();
t2.start();
}
}
【运行结果】
【分析】
本例中，占用锁的线程会持有锁6秒的时间，故另一个线程无法在5秒内获得锁，因此请求锁会失败。
如果tryLock( )不带参数，当前线程会尝试获得锁，如果锁并未被其他线程占用，则申请锁会成功，并立即返回true。
如果锁被其他线程占用，则当前线程不会进行等待，而是立即返回false。
tryLock()这种方式不会引起线程等待，因此也不会产生死锁。
【公平锁】
public ReentrantLock( boolean fair ); //fair=true，公平锁
公平锁会按照时间的顺序，保证先到者先获得锁，后到者后获得锁。公平锁最大的一个特点就是：不会产生饥饿现象。只要你排队，最终还是可以等到锁的。（如果使用synchronized关键字进行锁控制，那么产生的锁就是非公平的）
公平锁看起来很优美，但是其性能也非常低下，因此默认情况下，锁是非公平的，若没有特殊的需求，也不要使用公平锁。