本节主要从下述四个方面介绍重入锁。
1.什么是重入锁？
2.为什么要引用重入锁？
3.重入锁是怎么实现的？
4.分析java并发包中ReentrantLock。
什么是重入锁
重入锁，支持重进入的锁，表示该锁能够支持一个线程对它重复加锁，即线程在获得锁之后再次获取该锁时不会被阻塞。
为什么要引用重入锁？
以子类重写父类方法为例：
Mutix是不支持重入的锁。（代码摘抄自《java并发编程的艺术》）
1 import java.util.concurrent.TimeUnit;
2 import java.util.concurrent.locks.*;
3
4
5
6 public class Mutix implements Lock
7 {
8 private static class Sync extends AbstractQueuedSynchronizer{
9 //是否处于占用状态
10 protected boolean isHeldExclusively(){
11 return this.getState()==1;
12 }
13 protected boolean tryAcquire(int acquires){
14 if(compareAndSetState(0,1)){
15 setExclusiveOwnerThread(Thread.currentThread());
16 return true;
17 }
18 return false;
19
20 }
21 protected boolean tryRelease(int releases){
22 if(getState()==0)throw new IllegalMonitorStateException();
23 setExclusiveOwnerThread(null);
24 setState(0);
25
26 return true;
27
28 }
29 Condition newCondition(){
30 return new ConditionObject();
31 }
32
33 }
34 private final Sync sync=new Sync();
35
36 @Override
37 public void lock()
38 {
39 // TODO Auto-generated method stub
40 sync.acquire(1);
41 }
42
43 @Override
44 public void lockInterruptibly() throws InterruptedException
45 {
46 // TODO Auto-generated method stub
47 sync.acquireInterruptibly(1);
48 }
49
50 @Override
51 public Condition newCondition()
52 {
53 // TODO Auto-generated method stub
54 return sync.newCondition();
55 }
56
57 @Override
58 public boolean tryLock()
59 {
60 // TODO Auto-generated method stub
61 return sync.tryAcquire(1);
62 }
63
64 @Override
65 public boolean tryLock(long arg0, TimeUnit arg1)
66 throws InterruptedException
67 {
68 // TODO Auto-generated method stub
69 return sync.tryAcquireNanos(1, arg1.toNanos(arg0));
70 }
71
72 @Override
73 public void unlock()
74 {
75 // TODO Auto-generated method stub
76 sync.release(1);
77 }
78 public boolean hasQueuedThreads(){
79 return sync.hasQueuedThreads();
80 }
81
82 }
分别以支持重入和不支持重入进行测试；
测试代码如下：
1 import java.util.concurrent.locks.ReentrantLock;
2
3
4 public class TestLock
5 {
6 static Mutix lock=new Mutix();
7 // static ReentrantLock lock=new ReentrantLock();
8
9 public static class Widget {
10 public void doSomething() {
11 lock.lock();
12 try{
13 System.out.println("父类Widget,线程名称:" +Thread.currentThread().getName());
14 }finally{
15 lock.unlock();
16 }
17 }
18 }
19
20 public static class LoggingWidget extends Widget {
21 public void doSomething() {
22 lock.lock();
23 try{
24 System.out.println("子类LoggingWidget: calling doSomething,线程名称:" +Thread.currentThread().getName());
25 super.doSomething();
26 }finally{
27 lock.unlock();
28 }
29 }
30 }
31
32
33
34 /**
35 * @param args
36 */
37 public static void main(String[] args)
38 {
39 LoggingWidget test=new LoggingWidget();
40 test.doSomething();
41 }
42
43 }
当使用ReentrantLock可重入锁时，显示结果如下：
子类LoggingWidget: calling doSomething,线程名称:main
父类Widget,线程名称:main
当使用Mutix不可重入锁时，结果如下：
子类LoggingWidget: calling doSomething,线程名称:main
此时程序并没有结束，而是一直在等待父类的锁，通过jstack命令，查看到Main进程处于等待状态。按正常的处理逻辑，子类是允许调用父类的方法，故重入锁在实际应用中还是很重要的。
重入锁是怎么实现？
1）线程再次获取锁。需要判断当前获取锁的线程是否为当前占据锁的线程，如果是，则再次获取成功。
2）锁的最终释放。若线程重复了N次获得了锁，那需要释放N次才能真正释放该锁。线程再次获取锁时，计时器加1，当释放锁时，计数器减1。
分析java并发包中ReentrantLock。
1）自定义组合同步器实现锁的获取和释放，默认是以非公平形式获取锁。
1 final boolean nonfairTryAcquire(int acquires) {
2 final Thread current = Thread.currentThread();//当前线程
3 int c = getState();//获取同步状态
4 if (c == 0) {//如果同步状态为0，表示当前没有线程获取锁
5 if (compareAndSetState(0, acquires)) {//通过CAS算法获取锁
6 setExclusiveOwnerThread(current);
7 return true;
8 }
9 }
10 else if (current == getExclusiveOwnerThread()) {
11 //如果同步状态不为0，表示已经有线程获取了该锁，判断获取锁的线程是否为当前线程，如果时，同步状态加acquires，一般为加1
12 int nextc = c + acquires;
13 if (nextc < 0) // overflow
14 throw new Error("Maximum lock count exceeded");
15 setState(nextc);//设置同步状态
16 return true;
17 }
18 return false;
19 }
20
21 protected final boolean tryRelease(int releases) {
22 int c = getState() - releases;//计算当前同步状态减去releases
23 if (Thread.currentThread() != getExclusiveOwnerThread())//如果当前线程不等于获取锁的线程
24 throw new IllegalMonitorStateException();
25 boolean free = false;
26 if (c == 0) {//如果C==0,表示同步状态完全释放，将占用线程设置为Null,并且返回true
27 free = true;
28 setExclusiveOwnerThread(null);
29 }
30 setState(c);
31 return free;
32 }
在调用ReentrantLock的lock和unlock方法时，实际是调用同步器中的方法。
1 public boolean tryLock() {
2 return sync.nonfairTryAcquire(1);
3 }
4
5 public boolean tryLock(long timeout, TimeUnit unit)
6 throws InterruptedException {
7 return sync.tryAcquireNanos(1, unit.toNanos(timeout));
8 }
9 public void unlock() {
10 sync.release(1);
11 }
从代码中可以看到，最终调用的是sync中的方法，对于用户而言，sync是透明的。
2）公平和非公平获取锁。
1 /**
2 * Sync object for non-fair locks
3 */
4 static final class NonfairSync extends Sync {
5 private static final long serialVersionUID = 7316153563782823691L;
6
7 /**
8 * Performs lock. Try immediate barge, backing up to normal
9 * acquire on failure.
10 */
11 final void lock() {
12 if (compareAndSetState(0, 1))
13 setExclusiveOwnerThread(Thread.currentThread());
14 else
15 acquire(1);
16 }
17
18 protected final boolean tryAcquire(int acquires) {
19 return nonfairTryAcquire(acquires);
20 //直接调用Sync的方法。
21 }
22 }
1 static final class FairSync extends Sync {
2 private static final long serialVersionUID = -3000897897090466540L;
3
4 final void lock() {
5 acquire(1);
6 }
7
8 /**
9 * Fair version of tryAcquire. Don't grant access unless
10 * recursive call or no waiters or is first.
11 */
12 protected final boolean tryAcquire(int acquires) {
13 final Thread current = Thread.currentThread();
14 int c = getState();
15 if (c == 0) {
16 if (!hasQueuedPredecessors() &&
17 compareAndSetState(0, acquires)) {
18 setExclusiveOwnerThread(current);
19 return true;
20 }
21 }
22 else if (current == getExclusiveOwnerThread()) {
23 int nextc = c + acquires;
24 if (nextc < 0)
25 throw new Error("Maximum lock count exceeded");
26 setState(nextc);
27 return true;
28 }
29 return false;
30 }
31 }
公平和非公平最大区别在于：公平锁需要判断当前节点的前一个节点是否为头节点(hasQueuedPredecessors() )，如果是，才允许通过CAS算法获取锁，如果不是，表示有线程比当前线程更早的获取锁，因此需要等待前驱线程获取锁并释放锁之后才能继续获取锁。非公平不需要进行判断。公平锁保证了线程处理之间的公平，通过FIFO，保证了公平性，而代价是进行大量的线程切换。非公平锁虽然有时会造成线程饥饿，但极少的线程切换，保证了更大的吞吐量。
ReentrantLock锁默认采用的是非公平锁。
1 public ReentrantLock() {
2 sync = new NonfairSync();//默认采用非公平锁
3 }
总结：最近这几天在看《JAVA并发编程的艺术》，作者讲解的很详细，本来不想写博客，网上关于这些的文章已经非常多了，而且该书讲解的那么透彻，但后来想想，在写博客其实也是整理、梳理知识的过程，如果自己都没有弄明白，如何能够写出来。
来源：https://www.cnblogs.com/icbcfang/p/4769872.html