JUC-Lock
- Lock接口:
- Lock接口定义了比同步原语更灵活、更轻巧锁机制;同时,支持多种条件关联锁
- JUC的Lock接口的基本实现为ReentrantLock
- ReentrantLock支持公平、非公平、可重入的互斥同步锁
ReentrantLock
1.ReentrantLock分为两种实现,非公平以及公平模式;
2.公平模式基于CAS+队列实现,而非公平模式则是仅基于CAS实现
3.ReentrantLock中的队列,本质上是基于AQS实现的;而AQS本质上只是一个维持了内存可见的state的双向队列
- ReentrantLock中Node的状态字
//代表当前线程取消竞争锁 static final int CANCELLED = 1; //代表当前节点正常 static final int SIGNAL = -1; //代表当前线程在等待条件 static final int CONDITION = -2; //无法理解....... static final int PROPAGATE = -3; //表示状态字;只能用于以上四个状态字以及0 volatile int waitStatus;
- ReentrantLock构造方法
//默认为非公平实现 public ReentrantLock() { sync = new NonfairSync(); } //通过传入fair变量控制; //fair=true,公平锁实现;否则非公平实现 public ReentrantLock(boolean fair) { sync = fair ? new FairSync() : new NonfairSync(); }
- sync是什么?
- Sync是基于AQS实现的ReentrantLock锁同步控制基础
- 如下:
- ReentrantLock#lock()方法
final void lock() { acquire(1); }
- ReentrantLock中acquire方法基于AQS
public final void acquire(int arg) { //至少尝试获取一次锁; //如果锁没有获取成功,则将当前线程加入等待队列; //并且中断当前线程 if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) selfInterrupt(); } • ReentrantLock#tryAcquire(int args)
- 尝试获取锁的公平版本
- 非公平版本其实就是略去了公平版本的队列判断:hasQueuedPredecessors()
protected final boolean tryAcquire(int acquires) { //当前线程ID final Thread current = Thread.currentThread(); //当前锁状态 int c = getState(); //如果当前锁无人占有 if (c == 0) { //公平锁讲究先来后到 //如果当前等待队列没有等待线程, //且通过CAS成功改变锁的状态 if (!hasQueuedPredecessors() && compareAndSetState(0, acquires)) { //设置当前锁持有的线程 setExclusiveOwnerThread(current); return true; } } //如当前事务请求线程与当前事务执行线程是一样的;可重入锁特性 //这里就是可重入锁特性:同一线程可以重复获取同一把锁 else if (current == getExclusiveOwnerThread()) { //那么将当前锁持有状态+1 //通过设置acquires=1来完成可重入锁特性 int nextc = c + acquires; //这里对可重入锁的限制,当同一线程持有锁达到int的上限时; //会抛出异常 if (nextc < 0) throw new Error("Maximum lock count exceeded"); //并且重新改变state setState(nextc); return true; } return false; } • ReentrantLock#addWaiter() • 将当前等待线程以排它模式入队 private Node addWaiter(Node mode) { //以当前线程建立Node,并且设置Node的模式为排它 Node node = new Node(Thread.currentThread(), mode); // Try the fast path of enq; backup to full enq on failure Node pred = tail; if (pred != null) { node.prev = pred; //通过CAS修改队尾指针,新增等待线程 if (compareAndSetTail(pred, node)) { pred.next = node; return node; } } //通过自旋追加节点 enq(node); return node; }
- ReentrantLock#acquireQueued()
- 通过自旋不停的获取锁
final boolean acquireQueued(final Node node, int arg) { boolean failed = true; try { boolean interrupted = false; for (;;) { //获取p的前置节点 final Node p = node.predecessor(); //如果p的前置节点为head哑节点 //则说明p节点为阻塞队列的对头元素 //在AQS的CLH队列中,只有队头元素才能抢占锁 //且尝试获取锁成功,则返回false //当返回false时,则说明当前线程不需要挂起 if (p == head && tryAcquire(arg)) { setHead(node); p.next = null; // help GC failed = false; return interrupted; } //如果事情发展到这一步; //则说明前一步骤中,当前线程不在队列的头部 //或者没有抢占锁成功,则需要将当前线程挂起 if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) interrupted = true; } } finally { //当自身获取锁出现异常时 if (failed) cancelAcquire(node); } } • ReentrantLock#shouldParkAfterFailedAcquire() • 检验当前线程是否需要挂起 • 每个线程第一次进入该方法时,都为false;当第二次进入时才为true
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) { //前驱节点状态字 int ws = pred.waitStatus; //前驱节点正常;我需要挂起 if (ws == Node.SIGNAL)//-1 return true; //当状态字大于0,说明前驱节点取消竞争锁; //此时不停的寻找状态字小于0的节点; //因为前驱节点的状态字影响了自身的行为; //自身线程的行为依赖于前驱节点的状态字 if (ws > 0) {//1 do { node.prev = pred = pred.prev; } while (pred.waitStatus > 0); pred.next = node; } else { //当一个新的节点进入队列时,默认status为0; //因此需要将前驱节点的status设置为-1; compareAndSetWaitStatus(pred, ws, Node.SIGNAL); } return false; }
- ReentrantLock#parkAndCheckInterrupt()
- 挂起当前线程
private final boolean parkAndCheckInterrupt() { //挂起当前线程 LockSupport.park(this); return Thread.interrupted(); }
- ReentrantLock#release()
- 释放当前线程,唤醒等待线程
public final boolean release(int arg) { if (tryRelease(arg)) { Node h = head; if (h != null && h.waitStatus != 0) //唤醒后继节点线程 unparkSuccessor(h); return true; } return false; }
- ReentrantLock#tryRelease()
- 尝试释放当前线程
protected final boolean tryRelease(int releases) { //state表示锁状态;亦是当前线程持有锁的数目 //可重入锁的释放 int c = getState() - releases; //如果当前线程不是锁的持有者 if (Thread.currentThread() != getExclusiveOwnerThread()) throw new IllegalMonitorStateException(); boolean free = false; //如果说c==0;则说明当前线程持有的锁已经完全释放 //可重入锁,一个线程可以多次请求同一把锁 if (c == 0) { free = true; //设置当前锁的持有线程为null setExclusiveOwnerThread(null); } //修改状态位 setState(c); return free; }
- ReentrantLock#unparkSuccessor()
- 唤醒后继线程
private void unparkSuccessor(Node node) { //head节点的状态 int ws = node.waitStatus; if (ws < 0) //修改head节点的状态,以影响后继节点 compareAndSetWaitStatus(node, ws, 0); Node s = node.next; if (s == null || s.waitStatus > 0) { s = null; //从后面往前面找,找最接近头节点的小于0的线程 for (Node t = tail; t != null && t != node; t = t.prev) if (t.waitStatus <= 0) s = t; } //如果存在状态位小于0的线程 if (s != null) //唤醒线程 LockSupport.unpark(s.thread); }
