目录
AQS- 抽象队列同步器
AQS是抽象队列同步器；是一个抽象类，通过继承的方式使用；内部实现CLH队列，是一个FIFO的双向链表；基于自旋策略获取锁/释放锁资源。
AQS能降低构建锁和提高同步的效率，还避免多处位置上锁竞争问题。在AQS构建的同步器中，只在一个时刻发生阻塞，从而降低上下文切换的开销
AQS主要组成部分：Node head，Node tail，int state
Node主要组成部分：Node prev,Node next,Thread thread,int waitStatus等
waitStatus状态：
CANCELLED:当前节点线程已取消
SIGNAL:当前节点资源释放后,唤醒后继节点
CONDITION：等待队列转移到同步队列中，等待获取同步锁
PROPAGATE：当前节点的下一个节点无条件被执行
0：新节点入队时的默认状态
AQS- 抽象队列链表结构
AQS- 核心方法入队出队
AQS- 核心方法入队加锁
acquire入队核心流程：
| AbstractQueuedSynchronizer.acquire(int) |
acquire入队核心方法
tryAcquire：尝试获取同步状态，失败后 addWaiter，由子类实现
addWaiter：添加node节点
end:添加头节点
acquireQueued：获取队列同步状态
shouldParkAfterFailedAcquire：获取资源失败后是否需要阻塞(节点取消|资源释放移除队列)
parkAndCheckInterrupt：检测并停止当前节点线程
| public final void acquire(int arg) { |
tryAcquire方法
由具体子类实现，略
addWaiter方法
| private Node addWaiter(Node mode) { //末节点为空 |
enq方法
| private Node enq(final Node node) { |
acquireQueued方法
| 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)) {//判定是否头结点且获取锁同步状态 setHead(node);//设置新的头结点，将前节点移除队列 p.next = null; // help GC failed = false; return interrupted; } //阻塞当前节点 if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())//阻塞当前线程 interrupted = true; } } finally { if (failed)//失败后移除队列 cancelAcquire(node); } } |
shouldParkAfterFailedAcquire方法
| private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) { int ws = pred.waitStatus; if (ws == Node.SIGNAL)//前置节点结束后,通知当前节点 return true; if (ws > 0) { do {//循环移除取消的前置节点 node.prev = pred = pred.prev; } while (pred.waitStatus > 0); pred.next = node; } else {//前置节点正常，设置为SIGNAL，用于前置节点释放资源后，通知后置节点 compareAndSetWaitStatus(pred, ws, Node.SIGNAL); } return false; } |
parkAndCheckInterrupt方法
| private final boolean parkAndCheckInterrupt() { LockSupport.park(this);//使当前线程waiting中 return Thread.interrupted();//判断线程是否停止 } |
AQS- 核心方法出队解锁
release出队核心流程
| java.util.concurrent.locks.AbstractQueuedSynchronizer.release(int) java.util.concurrent.locks.AbstractQueuedSynchronizer.tryRelease(int) java.util.concurrent.locks.AbstractQueuedSynchronizer.unparkSuccessor(Node) java.util.concurrent.locks.AbstractQueuedSynchronizer.compareAndSetWaitStatus(Node, int, int) java.util.concurrent.locks.LockSupport.unpark(Thread) |
release出队核心方法
tryRelease：尝试获取资源，由子类实现
unparkSuccessor：唤醒等待队列里的下一个线程
tryRelease方法
由子类实现，略
unparkSuccessor方法
| private void unparkSuccessor(Node node) { int ws = node.waitStatus; if (ws < 0)//设置当前结点为0，且允许失败 compareAndSetWaitStatus(node, ws, 0); 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);找到最靠前的节点唤醒禁止状态 } |
AQS- 具体实现及应用场景
核心实现,属性,方法
一般情况：通过内部类 Sync 继承AbstractQueuedSynchronizer 实现；
线程池是通过内部类Worker继承AbstractQueuedSynchronizer实现
见下图：
AQS是没有实现任何同步接口的，它仅仅只是定义了同步状态的获取和释放的方法来供自定义的同步组件的使用。
AQS分为独享模式（如：ReentrantLock，ThreadPoolExecutor），共享模式（如：CountDownLatch，Semaphore，ReentrantReadWriteLock）
同步状态
volatile int state ; 一般0:无锁状态，1:有锁状态
final boolean compareAndSetState(int expect, int update);变更state状态
独享模式需要实现接口
Boolean tryAcquire(int arg) : 独享式获取同步状态
Boolean tryRelease(int arg) ：独享式释放同步状态
共享模式需要实现接口
int tryAcquireShared(int arg) ：共享式获取同步状态
Boolean tryReleaseShared(int arg) ：共享式释放同步状态
Boolean isHeldExclusively() ： 是否在独享模式下被线程占用
CountDownLatch共享子类
应用场景：1.一个线程等待多个线程执行完后执行；2.限定同时执行线程的最大数量
共享模式下,通过cas对state状态每次减1实现同步逻辑
用于多线程并行执行,当所有线程执行完后释放锁;耗时为最晚执行完的线程用时
| package java.util.concurrent; import java.util.concurrent.locks.AbstractQueuedSynchronizer; public class CountDownLatch { private static final class Sync extends AbstractQueuedSynchronizer { private static final long serialVersionUID = 4982264981922014374L; Sync(int count) {//state 大小 setState(count); } int getCount() { return getState(); } protected int tryAcquireShared(int acquires) { return (getState() == 0) ? 1 : -1; } //CountDownLatch.countDown 每次cas对state减1,并返回获取资源结果 protected boolean tryReleaseShared(int releases) { for (;;) { int c = getState(); if (c == 0) return false; int nextc = c-1; if (compareAndSetState(c, nextc)) return nextc == 0; } } } private final Sync sync; //构造AQS对象并初始化state public CountDownLatch(int count) { if (count < 0) throw new IllegalArgumentException("count < 0"); this.sync = new Sync(count); } //cas等待state变更为0,释放锁 public void await() throws InterruptedException { sync.acquireSharedInterruptibly(1); } public boolean await(long timeout, TimeUnit unit) throws InterruptedException { return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout)); } //cas更新state状态减1 public void countDown() { sync.releaseShared(1); } public long getCount() { return sync.getCount(); } public String toString() { return super.toString() + "[Count = " + sync.getCount() + "]"; } } |
Semaphore 共享子类
应用场景：1.控制同时访问共享资源的线程数量，可用于限流
线程共享模式下,默认是非公平模式，通过cas对state状态每次减1消耗资源，当state小于0时，cas阻塞;线程执行完成过后state+1；当state>0重新释放资源，csa阻塞释放(现实场景停车场)。
| public class Semaphore implements java.io.Serializable { private static final long serialVersionUID = -3222578661600680210L; private final Sync sync; abstract static class Sync extends AbstractQueuedSynchronizer { Sync(int permits) {//初始化信号量 setState(permits); } final int getPermits() {//获取信号量 return getState(); }//非公平锁尝试获取资源,acquires获取信号数量 final int nonfairTryAcquireShared(int acquires) { for (;;) { int available = getState(); int remaining = available - acquires; if (remaining < 0 || compareAndSetState(available, remaining)) return remaining; } }//释放资源,releases释放信号数量 protected final boolean tryReleaseShared(int releases) { for (;;) { int current = getState(); int next = current + releases; if (next < current) // overflow throw new Error("Maximum permit count exceeded"); if (compareAndSetState(current, next)) return true; } }//减少信号量 final void reducePermits(int reductions) { for (;;) { int current = getState(); int next = current - reductions; if (next > current) // underflow throw new Error("Permit count underflow"); if (compareAndSetState(current, next)) return; } } }//非公平共享模式 static final class NonfairSync extends Sync { private static final long serialVersionUID = -2694183684443567898L; NonfairSync(int permits) { super(permits); }//非公平锁尝试获取资源 protected int tryAcquireShared(int acquires) { return nonfairTryAcquireShared(acquires); } }//公平共享模式 static final class FairSync extends Sync { FairSync(int permits) { super(permits); }//公平锁尝试获取资源 protected int tryAcquireShared(int acquires) { for (;;) { if (hasQueuedPredecessors()) return -1; int available = getState(); int remaining = available - acquires; if (remaining < 0 || compareAndSetState(available, remaining)) return remaining; } } }//初始默认信号量 public Semaphore(int permits) { sync = new NonfairSync(permits); }//指定公平锁模式初始化信号量 public Semaphore(int permits, boolean fair) { sync = fair ? new FairSync(permits) : new NonfairSync(permits); }//获取信号量，获取失败cas阻塞当前线程 public void acquire() throws InterruptedException { sync.acquireSharedInterruptibly(1); }//唤醒等待的信号 public void acquireUninterruptibly() { sync.acquireShared(1); }//获取信号量，返回获取结果 public boolean tryAcquire() { return sync.nonfairTryAcquireShared(1) >= 0; }//释放信号量 public void release() { sync.releaseShared(1); } 。。。部分代码省略 } |
ReentrantReadWriteLock 共享子类
应用场景：1.读多写少场景(如缓存)
ReentrantReadWriteLock分为读锁(ReadLock)，写锁(WriteLock);ReadLock读锁是共享模式，WriteLock写锁是独享模式并且阻塞读锁
int(32位) state状态读锁，写锁共享字段，读锁取高16位 >0 读锁占用;写锁取低16位 >0写锁占用
| public class ReentrantReadWriteLock implements ReadWriteLock, java.io.Serializable { private final ReentrantReadWriteLock.ReadLock readerLock;//读锁 private final ReentrantReadWriteLock.WriteLock writerLock;//写锁 final Sync sync; public ReentrantReadWriteLock() { this(false);//默认情况非公平模式 } public ReentrantReadWriteLock(boolean fair) { sync = fair ? new FairSync() : new NonfairSync(); readerLock = new ReadLock(this); writerLock = new WriteLock(this); } public ReentrantReadWriteLock.WriteLock writeLock() { return writerLock; } public ReentrantReadWriteLock.ReadLock readLock() { return readerLock; } abstract static class Sync extends AbstractQueuedSynchronizer { Sync() { readHolds = new ThreadLocalHoldCounter(); setState(getState()); // ensures visibility of readHolds }//共享读锁数量 static int sharedCount(int c) { return c >>> SHARED_SHIFT; } //独享写锁数量 static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; } abstract boolean readerShouldBlock();//是否存在读锁 abstract boolean writerShouldBlock();//是否存在写锁 protected final boolean tryRelease(int releases) {//尝试释放独享锁 if (!isHeldExclusively()) throw new IllegalMonitorStateException(); int nextc = getState() - releases; boolean free = exclusiveCount(nextc) == 0; if (free) setExclusiveOwnerThread(null);//清空主线程 setState(nextc); return free; } protected final boolean tryAcquire(int acquires) {//尝试获取独享写锁 Thread current = Thread.currentThread(); int c = getState(); int w = exclusiveCount(c); if (c != 0) { if (w == 0 || current != getExclusiveOwnerThread()) return false; if (w + exclusiveCount(acquires) > MAX_COUNT)//最大写锁粒度65535 throw new Error("Maximum lock count exceeded"); setState(c + acquires); return true; } if (writerShouldBlock() || !compareAndSetState(c, c + acquires)) return false; setExclusiveOwnerThread(current); return true; } protected final boolean tryReleaseShared(int unused) {//尝试释放共享锁 Thread current = Thread.currentThread(); if (firstReader == current) {//释放共享锁计数 if (firstReaderHoldCount == 1) firstReader = null; else firstReaderHoldCount--; } else {//释放其他线程计数 HoldCounter rh = cachedHoldCounter; if (rh == null || rh.tid != getThreadId(current)) rh = readHolds.get(); int count = rh.count; if (count <= 1) { readHolds.remove(); if (count <= 0) throw unmatchedUnlockException(); } --rh.count; } for (;;) { int c = getState(); int nextc = c - SHARED_UNIT; if (compareAndSetState(c, nextc)) return nextc == 0; } } protected final int tryAcquireShared(int unused) {//尝试获取共享读锁 Thread current = Thread.currentThread(); int c = getState(); if (exclusiveCount(c) != 0 &&//存在独享写锁，获取失败 getExclusiveOwnerThread() != current) return -1; int r = sharedCount(c); if (!readerShouldBlock() && r < MAX_COUNT && compareAndSetState(c, c + SHARED_UNIT)) { if (r == 0) { firstReader = current; firstReaderHoldCount = 1;//共享读锁计数 } else if (firstReader == current) { firstReaderHoldCount++;//共享读锁计数 } else {//其他线程共享读锁计数 HoldCounter rh = cachedHoldCounter; if (rh == null || rh.tid != getThreadId(current)) cachedHoldCounter = rh = readHolds.get(); else if (rh.count == 0) readHolds.set(rh); rh.count++; } return 1; } return fullTryAcquireShared(current); } final boolean tryWriteLock() {//尝试写加锁 Thread current = Thread.currentThread(); int c = getState(); if (c != 0) { int w = exclusiveCount(c); if (w == 0 || current != getExclusiveOwnerThread()) return false; if (w == MAX_COUNT)//最大写锁计数65535 throw new Error("Maximum lock count exceeded"); } if (!compareAndSetState(c, c + 1)) return false; setExclusiveOwnerThread(current); return true; } final boolean tryReadLock() {//尝试读加锁 Thread current = Thread.currentThread(); for (;;) { int c = getState(); if (exclusiveCount(c) != 0 &&//存在独享写锁计数，获取失败 getExclusiveOwnerThread() != current) return false; int r = sharedCount(c); if (r == MAX_COUNT)//最大读锁计数65535 throw new Error("Maximum lock count exceeded"); if (compareAndSetState(c, c + SHARED_UNIT)) { if (r == 0) { firstReader = current; firstReaderHoldCount = 1;//共享读锁计数 } else if (firstReader == current) { firstReaderHoldCount++;//共享读锁计数 } else {//其他线程共享读锁计数 HoldCounter rh = cachedHoldCounter; if (rh == null || rh.tid != getThreadId(current)) cachedHoldCounter = rh = readHolds.get(); else if (rh.count == 0) readHolds.set(rh); rh.count++; } return true; } } } //非公平模式 static final class NonfairSync extends Sync { final boolean writerShouldBlock() { return false; // writers can always barge } }//公平模式 static final class FairSync extends Sync { final boolean writerShouldBlock() { return hasQueuedPredecessors(); } final boolean readerShouldBlock() { return hasQueuedPredecessors(); } }//读锁实现，部分代码忽略 public static class ReadLock implements Lock, java.io.Serializable { private final Sync sync; protected ReadLock(ReentrantReadWriteLock lock) { sync = lock.sync; } public void lock() {//读锁加锁 sync.acquireShared(1);//共享模式加锁 } public boolean tryLock() {//尝试加锁 return sync.tryReadLock(); } public void unlock() {//共享模式释放锁 sync.releaseShared(1); } }//写锁实现，部分代码忽略 public static class WriteLock implements Lock, java.io.Serializable { private final Sync sync; protected WriteLock(ReentrantReadWriteLock lock) { sync = lock.sync; } public void lock() {//写锁加锁 sync.acquire(1);//独享模式加锁 } public boolean tryLock( ) {//尝试加锁 return sync.tryWriteLock(); } public void unlock() {//独享模式释放锁 sync.release(1); } } public int getReadLockCount() {//获取读锁计数取高16位 return sync.getReadLockCount(); } 。。。部分代码省略 } |
ReentrantLock 独享子类
应用场景:1.多线程串行执行；2.防止并发保证数据安全
将多线程并行任务通过CAS实现线程的串行执行，从而达到线程安全性的目的。而Lock是juc中实现的锁接口
| public class ReentrantLock implements Lock, java.io.Serializable { private final Sync sync; abstract static class Sync extends AbstractQueuedSynchronizer { abstract void lock();//抽象锁接口，子类实现 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; } 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; } final boolean isLocked() {//判定锁状态 return getState() != 0; } } static final class NonfairSync extends Sync {//非公平方式实现 final void lock() {//实现锁所有线程 if (compareAndSetState(0, 1))//cas等待,state为0时，修改为1 setExclusiveOwnerThread(Thread.currentThread()); else acquire(1); } protected final boolean tryAcquire(int acquires) {//尝试获取资源 return nonfairTryAcquire(acquires); } } static final class FairSync extends Sync {//公平方式 final void lock() {//实现锁所有线程 acquire(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 ReentrantLock() {//初始化锁对象，默认非公平锁 sync = new NonfairSync(); } public ReentrantLock(boolean fair) {//初始化锁对象，设置公平模式 sync = fair ? new FairSync() : new NonfairSync(); } public void lock() {//加锁 sync.lock(); } public boolean tryLock() {//尝试加锁 return sync.nonfairTryAcquire(1); } public void unlock() {//释放锁 sync.release(1); } public boolean isLocked() {判定锁的状态 return sync.isLocked(); } 。。。部分代码省略 } |
232
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
