Java学习笔记9AQS抽象队列同步器
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<Thread> owner = new AtomicReference<>();
// 等待集合（锁池）
volatile LinkedBlockingQueue<Thread> 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<Thread> 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<Thread> 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<T> implements Runnable {
Callable<T> callable; //包装了业务逻辑代码
T result; //线程执行结果
volatile String state = "NEW"; //任务执行的状态
// 容器把等待中的线程保存起来 -- 停车场
LinkedBlockingQueue<Thread> waiters = new LinkedBlockingQueue<>();
public MyFutureTaskTest(Callable<T> 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;
}
}
以上是 Java学习笔记9AQS抽象队列同步器 的全部内容， 来源链接： utcz.com/z/511197.html
