本文介绍ReentrantLock加锁解锁过程
在看这个类的代码时，先看类的关系，ReentrantLock，内部有sync类，继承了AbstractQueuedSynchronizer，这个类中封装很多锁的公共方法，比如，获取锁，释放锁，创建队列，入队，阻塞，共享锁的逻辑。
测试代码：
import java.util.concurrent.locks.ReentrantLock;
public class TestLock {
public static void main(String[] args) {
ReentrantLock lock = new ReentrantLock(false);
for (int i = 0; i < 5; i++) {
new Thread(()->{
lock.lock();
try{
System.out.println(Thread.currentThread().getName()+"-----开始");
}finally {
lock.unlock();
}
},"thread"+i).start();
}
}
}断点设置方式，断点处右键就出现了
源码介绍
创建非公平锁
// 创建锁ReentrantLock lock = new ReentrantLock(false);
// 创建的是非公平锁NonfairSync
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
// 空参构造，默认创建的 是非公平锁，
public ReentrantLock() {
sync = new NonfairSync();
}
//非公平锁效率比公平锁高，因为，有时候不存在入队，阻塞，唤醒等操作，一个新的线程进来竞争锁，有可能一
//下就得到锁，直接运行代码。lock.lock()分析
// java.util.concurrent.locks.ReentrantLock#lock
public void lock() {
sync.lock();
}由于上面创建的非公平锁NonfairSync，调用它的lock（）方法；
static final class NonfairSync extends Sync {
private static final long serialVersionUID = 7316153563782823691L;
/**
* Performs lock. Try immediate barge, backing up to normal
* acquire on failure.
*/
final void lock() {
// CAS操作state从0改为1，改成功说明加锁成功进入下面的设置拥有锁的线程
if (compareAndSetState(0, 1))
// 设置排他线程，锁的拥有线程
setExclusiveOwnerThread(Thread.currentThread());
else
// 如果state值不是0，尝试获取锁，包含可重入锁
acquire(1);
}
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
}如果是第一个线程进来，在if成功后就返回了，获取了锁，后面的线程进来都会进入else，下面看acquire(1);方法
//java.util.concurrent.locks.AbstractQueuedSynchronizer#acquire
public final void acquire(int arg) {
// 尝试获取锁，这个节点，如果上一个线程正好释放锁，这里就能获取成功，跳出if
//获取锁失败，进入下一个判断
if (!tryAcquire(arg) &&
//先执行addWaiter(..);方法创建队列，入队，
//再执行外面方法，进入阻塞
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
//设置中断标记，调试时，不进入这个方法，不知道什么情况进入
selfInterrupt();
}先看创建队列、入队
//java.util.concurrent.locks.AbstractQueuedSynchronizer#addWaiter
private Node addWaiter(Node mode) {
//创建一个节点，包含当前线程，mode=null
Node node = new Node(Thread.currentThread(), mode);
// Try the fast path of enq; backup to full enq on failure
Node pred = tail;
// tail !=null 说明有队列，这里只需要节点入队，并返回
if (pred != null) {
node.prev = pred;
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
//第2线程进来没有获取锁，就进入这个方法，创建队列并入队
enq(node);
return node;
}再看enq（node）;
//java.util.concurrent.locks.AbstractQueuedSynchronizer#enq
private Node enq(final Node node) {
//这里是循环，最少会循环2次，直到节点入队成功
for (;;) {
//第一次进入循环，tail == null
Node t = tail;
if (t == null) { // Must initialize
//创建队列，1创建空节点，2设置为头节点
if (compareAndSetHead(new Node()))
// tail也指向这个新创建的节点
tail = head;
} else {
//第2次循环，进入这，入队
node.prev = t;
// CAS操作节点入队尾，
if (compareAndSetTail(t, node)) {
//成功入队，建立双向链表结构
t.next = node;
return t;
}
}
}
}再看acquireQueued(addWaiter(Node.EXCLUSIVE), arg))这个方法
参数中的node就是没有获取锁的第2个线程
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
//经典循环；
for (;;) {
final Node p = node.predecessor();
// 先判断此节点前一个是不是头节点，入队后在阻塞之前再次尝试获取锁，
if (p == head && tryAcquire(arg)) {
//下一个节点被唤醒，获取锁成功后修改为head，将节点中的thread和prev置为null
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
// shouldParkAfterFailedAcquire（..）会执行2次，第一次设置上一个节点p--waitStatus=-1
//下次进入循环，才会返回true
if (shouldParkAfterFailedAcquire(p, node) &&
// 进入阻塞，返回中断状态
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
// 这里设置head
private void setHead(Node node) {
head = node;
node.thread = null;
node.prev = null;
}private final boolean parkAndCheckInterrupt() {
// 阻塞，等待被唤醒
LockSupport.park(this);
//判断中断状态，并清除中断标记，这里一直返回false，不知道什么时候返回true。
return Thread.interrupted();
}如果第一个线程，不释放锁，后面的就都会进入这里阻塞。
阻塞队列
释放锁
调用非公平锁的unlock()方法
public void unlock() {
sync.release(1);
}public final boolean release(int arg) {
//尝试释放锁，就是将state-1
if (tryRelease(arg)) {
//取出head节点
Node h = head;
if (h != null && h.waitStatus != 0)
//释放锁
unparkSuccessor(h);
return true;
}
return false;
}//node是head节点
private void unparkSuccessor(Node node) {
/*
* If status is negative (i.e., possibly needing signal) try
* to clear in anticipation of signalling. It is OK if this
* fails or if status is changed by waiting thread.
*/
int ws = node.waitStatus;
if (ws < 0)
//设置waitStatus=0
compareAndSetWaitStatus(node, ws, 0);
/*
* Thread to unpark is held in successor, which is normally
* just the next node. But if cancelled or apparently null,
* traverse backwards from tail to find the actual
* non-cancelled successor.
*/
//取出下一个节点
Node s = node.next;
if (s == null || s.waitStatus > 0) {
s = null;
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
if (s != null)
//唤醒下一个节点
LockSupport.unpark(s.thread);
}下一个节点被唤醒之后，会进入
java.util.concurrent.locks.AbstractQueuedSynchronizer#parkAndCheckInterrupt
返回false，在返回上面的调用方法
java.util.concurrent.locks.AbstractQueuedSynchronizer#acquireQueued
进入for (;;)循环，被唤醒的是下一个节点，进入if方法，获取锁成功，设置为head节点。将head节点next值，置为null，等待被gc回收。
可重入：
就是一个线程多次调用lock.lock()方法，state的值就会加1.等释放锁的时候就减1，直到state=0；释放锁成功。
参考文章：写的不错，可以看看
8920
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
