Java高并发编程（六）：重入锁

朱雀 2022-04-02 05:08 275阅读 0赞

重入锁定义：重入锁ReentrantLock，就是支持重进入的锁，它表示该锁能够支持一个线程对资源的重复加锁。除此之外，该锁的还支持获取锁时的公平和非公平性选择。

ReentrantLock虽然没能像synchronized关键字一样支持隐式的重进入，但是在调用lock()方法时，已经获取到锁的线程，能够再次调用lock()方法获取锁而不被阻塞。

**ReentrantLock锁的公平性问题：**

*  非公平锁：对锁的获取对于所有线程都是公平的，所有线程都有相同的概率获取重入锁ReetranLock.
 *  公平锁：公平的获取锁，也就是等待时间最长的线程最优先获取锁，也可以说锁获取是顺序的。

# 1. ReentrantLock锁的实现机制 #

重入锁是指任意线程在获取到锁之后能够再次获取该锁而不会被锁所阻塞，该特性的实  
现需要解决以下两个问题：

> 1.  线程再次获取锁。锁需要去识别获取锁的线程是否为当前占据锁的线程，如果是，则再次成功获取。
> 2.  锁的最终释放。线程重复n次获取了锁，随后在第n次释放该锁后，其他线程能够获取到该锁。锁的最终释放要求锁对于获取进行计数自增，计数表示当前锁被重复获取的次数，而锁被释放时，计数自减，当计数等于0时表示锁已经成功释放。

ReentrantLock是通过组合自定义同步器来实现锁的获取与释放。

## 1.1 非公平锁的实现原理 ##

### 1.1.1 非公平锁的请求同步状态 ###

protected final boolean tryAcquire(int acquires) { 
                return nonfairTryAcquire(acquires);
            }
    
    final boolean nonfairTryAcquire(int acquires) { 
                final Thread current = Thread.currentThread();
                int c = getState();
                if (c == 0) { 
                    if (compareAndSetState(0, acquires)) { 
                        setExclusiveOwnerThread(current);
                        return true;
                    }
                }
                else if (current == getExclusiveOwnerThread()) { 
                    int nextc = c + acquires;
                    if (nextc < 0) // overflow
                        throw new Error("Maximum lock count exceeded");
                    setState(nextc);
                    return true;
                }
                return false;
            }

该方法增加了再次获取同步状态的处理逻辑：通过判断当前线程是否为获取锁的线程来  
决定获取操作是否成功，如果是获取锁的线程再次请求，则将同步状态值进行增加并返回  
true，表示获取同步状态成功。

### 1.1.2 非公平锁的释放同步状态 ###

成功获取锁的线程再次获取锁，只是增加了同步状态值，这也就要求ReentrantLock在释放  
同步状态时减少同步状态值。

protected final boolean tryRelease(int releases) { 
                int c = getState() - releases;
                if (Thread.currentThread() != getExclusiveOwnerThread())
                    throw new IllegalMonitorStateException();
                boolean free = false;
                if (c == 0) { 
                    free = true;
                    setExclusiveOwnerThread(null);
                }
                setState(c);
                return free;
            }

如果该锁被获取了n次，那么前(n-1)次tryRelease(int releases)方法必须返回false，而只有同步状态完全释放了，才能返回true。可以看到，该方法将同步状态是否为0作为最终释放的条件，当同步状态为0时，将占有线程设置为null，并返回true，表示释放成功。

## 1.2 公平锁的实现原理 ##

### 1.2.1 公平锁的请求同步状态 ###

protected final boolean tryAcquire(int acquires) { 
                final Thread current = Thread.currentThread();
                int c = getState();
                if (c == 0) { 
                    if (!hasQueuedPredecessors() &&
                        compareAndSetState(0, acquires)) { 
                        setExclusiveOwnerThread(current);
                        return true;
                    }
                }
                else if (current == getExclusiveOwnerThread()) { 
                    int nextc = c + acquires;
                    if (nextc < 0)
                        throw new Error("Maximum lock count exceeded");
                    setState(nextc);
                    return true;
                }
                return false;
            }
            
    public final boolean hasQueuedPredecessors() { 
    // The correctness of this depends on head being initialized
    // before tail and on head.next being accurate if the current
    // thread is first in queue.
        Node t = tail; // Read fields in reverse initialization order
        Node h = head;
        Node s;
        return h != t &&
            ((s = h.next) == null || s.thread != Thread.currentThread());
        }

该方法与nonfairTryAcquire(int acquires)比较，唯一不同的位置为判断条件多了hasQueuedPredecessors()方法，即加入了同步队列中当前节点是否有前驱节点的判断，如果该方法返回true，则表示有线程比当前线程更早地请求获取锁，因此需要等待前驱线程获取并释放锁之后才能继续获取锁。hasQueuedPredecessors()方法判断当线程是否是头节点的后驱节点。

## 1.2.2 公平锁的释放同步状态 ##

公平锁的释放同步状态方法和非公平锁释放同步状态方法一致，没有区别。

## 2. 公平锁和非公平锁的区别 ##

公平锁和非公平锁，在CHL队列抢占模式上都是一致的，也就是在进入acquireQueued这个方法之后都一样，它们的区别在初次抢占上有区别，也就是tryAcquire上的区别，下面是两者内部调用关系的简图：

真正的区别就是公平锁多了hasQueuePredecessors这个方法，这个方法用于判断CHL队列中是否有节点，对于公平锁，如果CHL队列有节点，则新进入竞争的线程一定要在CHL上排队，而非公平锁则是无视CHL队列中的节点，直接进行竞争抢占，这就有可能导致CHL队列上的节点永远获取不到锁，这就是非公平锁之所以不公平的原因。

## 3. 公平锁与非公平锁的性能差异 ##

公平性锁保证了锁的获取按照FIFO原则，而代价是进行大量的线程切换。非公平性锁虽然可能造成线程“饥饿”，但极少的线程切换，保证了其更大的吞吐量。