java aqs 等待队列_Java学习笔记9-AQS抽象队列同步器

Java学习笔记9-AQS抽象队列同步器

AQS抽象队列同步器

我们看下Lock相关源码发现 JDK内部将一些共性逻辑抽象为AbstractQueuedSynchronizer类，应用模版方法设计模式通过子类实现不同锁的效果。AQS提供了对资源占用、释放，线程的等待、唤醒等接口和具体实现。可以用在各种需要控制资源争用的场景中。(ReentrantLock / CountDownLatch / Semaphore)

AQS内部主体：state，owner，waiters

独占资源接口：acquire、tryAcquire、release、tryRelease

共享资源接口：acquireShared 、tryAcquireShared、releaseShared 、tryReleaseShared

acquire、 acquireShared ： 定义了资源争用的逻辑，如果没拿到，则等待。

tryAcquire、 tryAcquireShared ： 实际执行占用资源的操作，如何判定一个由使用者具体去实现。

release、 releaseShared ： 定义释放资源的逻辑，释放之后，通知后续节点进行争抢。

tryRelease、 tryReleaseShared： 实际执行资源释放的操作，具体的AQS使用者去实现。

下面我们把之前实现的锁抽象一下也写一个简易的AQS类

import java.util.Iterator;

import java.util.concurrent.LinkedBlockingQueue;

import java.util.concurrent.atomic.AtomicInteger;

import java.util.concurrent.atomic.AtomicReference;

import java.util.concurrent.locks.LockSupport;

public class AqsTest {

// 当前锁的拥有者

volatile AtomicReference owner = new AtomicReference<>();

// 等待集合(锁池)

volatile LinkedBlockingQueue waiters = new LinkedBlockingQueue<>();

// 记录锁的状态

volatile AtomicInteger state = new AtomicInteger(0);

/**

* 获取独占锁

*/

public void acquire() {

boolean addQ = true;

while (!tryAcquire()) {

if (addQ) {

// 没获取到锁，加入到等待集合中

waiters.offer(Thread.currentThread());

addQ = false;

} else {

// 挂起当前线程，等待其他线程释放

LockSupport.park(); // 收到 unpark 通知之后唤醒，继续循环

}

}

waiters.remove(Thread.currentThread()); // 从等待集合中移除线程

}

/**

* 释放独占锁

*/

public void release() {

if (tryRelease()) {

// 通知其他等待线程

Iterator iterator = waiters.iterator();

while (iterator.hasNext()) {

Thread waiter = iterator.next();

LockSupport.unpark(waiter); // 唤醒线程继续 抢锁

}

}

}

/**

* 获取共享锁

*/

public void acquireShared() {

boolean addQ = true;

while (tryAcquireShared() < 0) {

if (addQ) {

// 没获取到锁，加入到等待集合中

waiters.offer(Thread.currentThread());

addQ = false;

} else {

// 挂起当前线程，等待其他线程释放

LockSupport.park(); // 收到 unpark 通知之后唤醒，继续循环

}

}

waiters.remove(Thread.currentThread()); // 从等待集合中移除线程

}

/**

* 释放共享锁

*/

public void releaseShared() {

if (tryReleaseShared()) {

// 通知其他等待线程

Iterator iterator = waiters.iterator();

while (iterator.hasNext()) {

Thread waiter = iterator.next();

LockSupport.unpark(waiter); // 唤醒线程继续 抢锁

}

}

}

/**

* 获取独占锁逻辑，实际使用者去实现

*

* @return

*/

public boolean tryAcquire() {

throw new UnsupportedOperationException();

}

/**

* 释放独占锁逻辑，实际使用者去实现

*

* @return

*/

public boolean tryRelease() {

throw new UnsupportedOperationException();

}

/**

* 获取共享锁逻辑，实际使用者去实现

*

* @return

*/

public int tryAcquireShared() {

throw new UnsupportedOperationException();

}

/**

* 释放共享锁逻辑，实际使用者去实现

*

* @return

*/

public boolean tryReleaseShared() {

throw new UnsupportedOperationException();

}

public AtomicInteger getState() {

return state;

}

public void setState(AtomicInteger state) {

this.state = state;

}

}

我们再把之前自己实现的锁改造一下

import java.util.concurrent.TimeUnit;

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.Lock;

public class AqsLockTest implements Lock {

// 抽象工具类AQS

AqsTest aqs = new AqsTest() {

@Override

public boolean tryAcquire() {

return owner.compareAndSet(null, Thread.currentThread());

}

@Override

public boolean tryRelease() {

return owner.compareAndSet(Thread.currentThread(), null);

}

};

@Override

public boolean tryLock() {

return aqs.tryAcquire();

}

@Override

public void lock() {

aqs.acquire();

}

@Override

public void unlock() {

aqs.release();

}

@Override

public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {

return false;

}

@Override

public void lockInterruptibly() throws InterruptedException {

}

@Override

public Condition newCondition() {

return null;

}

}

看看这代码是不是有点意思了~

同步锁的本质 - 排队

同步的方式：独享锁 - 单个队列窗口，共享锁 - 多个队列窗口

抢锁的方式：插队抢(不公平锁)、先来后到抢锁(公平锁)

没抢到锁的处理方式：快速尝试多次(CAS自旋锁)、阻塞等待

唤醒阻塞线程的方式(叫号器)：全部通知、通知下一个

资源占用流程

acquire获取资源 --> 2

tryAcquire尝试抢资源 --没抢到资源--> 3

--抢到资源 --> 5

加入队列 --park--> 4

等待 --unpark--> 2

--interrupt--> 5

end

实现自己的FutureTask

我们实现了几个自己的功能类，虽然有点简易但按照这种方法去分析 JDK源码，模仿并实现自己的类才能更好的了解 JDK原理，下面我们分析特征来实现个自己的FutureTask

import java.util.concurrent.Callable;

import java.util.concurrent.LinkedBlockingQueue;

import java.util.concurrent.locks.LockSupport;

// 分析特征：构造函数/泛型/Runnable/GET返回结果

public class MyFutureTaskTest implements Runnable {

Callable callable; //包装了业务逻辑代码

T result; //线程执行结果

volatile String state = "NEW"; //任务执行的状态

// 容器把等待中的线程保存起来 -- 停车场

LinkedBlockingQueue waiters = new LinkedBlockingQueue<>();

public MyFutureTaskTest(Callable callable) {

this.callable = callable;

}

// 查询 -- 异步线程要去调用的

@Override

public void run() { //线程启动后，会执行run方法

System.out.println(Thread.currentThread().getName() + "开始执行");

// 业务逻辑执行

try {

result = callable.call();

} catch (Exception e) {

//result =

//state = "EXP"; //异常状态

e.printStackTrace();

} finally {

state = "END";

}

System.out.println(Thread.currentThread().getName() + "执行完了");

// TODO 唤醒等待的线程

System.out.println("阻塞进程数：" + waiters.size());

Thread waiter = waiters.poll(); //停车场取数据

while (waiter != null) {

System.out.println(waiter.getName() + "解除阻塞");

LockSupport.unpark(waiter); //唤醒指定的线程 --- waiter

System.out.println(waiter.getName() + "解除阻塞完毕");

waiter = waiters.poll(); //停车场取数据

}

}

// 调用 --- 方法执行主线程

public T get() { //获取返回值

if ("END".equals(state)) {

return result;

} //else if (exception) 抛出异常

// TODO 等待...如何控制线程的执行(停)，需要等待run 这个线程执行完毕

// 线程不继续执行代码，去什么地方？ 正在跑的车 ---> 停车场

while (!"END".equals(state)) {

waiters.add(Thread.currentThread());

System.out.println(Thread.currentThread().getName() + "准备阻塞");

LockSupport.park(); //当前线程阻塞等待 --- native方法控制 C++底层实现

System.out.println(Thread.currentThread().getName() + "阻塞完毕");

}

return result;

}

}