（1）aqs是什么？
（2）aqs的定位？
（3）aqs的实现原理？
（4）基于aqs实现自己的锁？
aqs的全称是abstractqueuedsynchronizer，它的定位是为java中几乎所有的锁和同步器提供一个基础框架。
aqs是基于fifo的队列实现的，并且内部维护了一个状态变量state，通过原子更新这个状态变量state即可以实现加锁解锁操作。
本章及后续章节的内容理解起来可能会比较晦涩，建议先阅读彤哥上一章的内容【死磕 java同步系列之自己动手写一个锁lock】。
我要评论static final class node {
// 标识一个节点是共享模式
static final node shared = new node();
// 标识一个节点是互斥模式
static final node exclusive = null;
// 标识线程已取消
static final int cancelled = 1;
// 标识后继节点需要唤醒
static final int signal = -1;
// 标识线程等待在一个条件上
static final int condition = -2;
// 标识后面的共享锁需要无条件的传播（共享锁需要连续唤醒读的线程）
static final int propagate = -3;
// 当前节点保存的线程对应的等待状态
volatile int waitstatus;
// 前一个节点
volatile node prev;
// 后一个节点
volatile node next;
// 当前节点保存的线程
volatile thread thread;
// 下一个等待在条件上的节点（condition锁时使用）
node nextwaiter;
// 是否是共享模式
final boolean isshared() {
return nextwaiter == shared;
}
// 获取前一个节点
final node predecessor() throws nullpointerexception {
node p = prev;
if (p == null)
throw new nullpointerexception();
else
return p;
}
// 节点的构造方法
node() { // used to establish initial head or shared marker
}
// 节点的构造方法
node(thread thread, node mode) { // used by addwaiter
// 把共享模式还是互斥模式存储到nextwaiter这个字段里面了
this.nextwaiter = mode;
this.thread = thread;
}
// 节点的构造方法
node(thread thread, int waitstatus) { // used by condition
// 等待的状态，在condition中使用
this.waitstatus = waitstatus;
this.thread = thread;
}
}
典型的双链表结构，节点中保存着当前线程、前一个节点、后一个节点以及线程的状态等信息。
// 队列的头节点 private transient volatile node head; // 队列的尾节点 private transient volatile node tail; // 控制加锁解锁的状态变量 private volatile int state;
定义了一个状态变量和一个队列，状态变量用来控制加锁解锁，队列用来放置等待的线程。
注意，这几个变量都要使用volatile关键字来修饰，因为是在多线程环境下操作，要保证它们的值修改之后对其它线程立即可见。
这几个变量的修改是直接使用的unsafe这个类来操作的：
// 获取unsafe类的实例，注意这种方式仅限于jdk自己使用，普通用户是无法这样调用的
private static final unsafe unsafe = unsafe.getunsafe();
// 状态变量state的偏移量
private static final long stateoffset;
// 头节点的偏移量
private static final long headoffset;
// 尾节点的偏移量
private static final long tailoffset;
// 等待状态的偏移量（node的属性）
private static final long waitstatusoffset;
// 下一个节点的偏移量（node的属性）
private static final long nextoffset;
static {
try {
// 获取state的偏移量
stateoffset = unsafe.objectfieldoffset
(abstractqueuedsynchronizer.class.getdeclaredfield("state"));
// 获取head的偏移量
headoffset = unsafe.objectfieldoffset
(abstractqueuedsynchronizer.class.getdeclaredfield("head"));
// 获取tail的偏移量
tailoffset = unsafe.objectfieldoffset
(abstractqueuedsynchronizer.class.getdeclaredfield("tail"));
// 获取waitstatus的偏移量
waitstatusoffset = unsafe.objectfieldoffset
(node.class.getdeclaredfield("waitstatus"));
// 获取next的偏移量
nextoffset = unsafe.objectfieldoffset
(node.class.getdeclaredfield("next"));
} catch (exception ex) { throw new error(ex); }
}
// 调用unsafe的方法原子更新state
protected final boolean compareandsetstate(int expect, int update) {
return unsafe.compareandswapint(this, stateoffset, expect, update);
}
关于unsafe类的讲解请参考彤哥之前写的【死磕 java魔法类之unsafe解析】。
我们可以看到aqs的全称是abstractqueuedsynchronizer，它本质上是一个抽象类，说明它本质上应该是需要子类来实现的，那么子类实现一个同步器需要实现哪些方法呢？
// 互斥模式下使用：尝试获取锁
protected boolean tryacquire(int arg) {
throw new unsupportedoperationexception();
}
// 互斥模式下使用：尝试释放锁
protected boolean tryrelease(int arg) {
throw new unsupportedoperationexception();
}
// 共享模式下使用：尝试获取锁
protected int tryacquireshared(int arg) {
throw new unsupportedoperationexception();
}
// 共享模式下使用：尝试释放锁
protected boolean tryreleaseshared(int arg) {
throw new unsupportedoperationexception();
}
// 如果当前线程独占着锁，返回true
protected boolean isheldexclusively() {
throw new unsupportedoperationexception();
}
问题：这几个方法为什么不直接定义成抽象方法呢？
因为子类只要实现这几个方法中的一部分就可以实现一个同步器了，所以不需要定义成抽象方法。
下面我们通过一个案例来介绍aqs中的部分方法。
直接上代码：
public class mylockbaseonaqs {
// 定义一个同步器，实现aqs类
private static class sync extends abstractqueuedsynchronizer {
// 实现tryacquire(acquires)方法
@override
public boolean tryacquire(int acquires) {
if (compareandsetstate(0, 1)) {
setexclusiveownerthread(thread.currentthread());
return true;
}
return false;
}
// 实现tryrelease(releases)方法
@override
protected boolean tryrelease(int releases) {
setexclusiveownerthread(null);
setstate(0);
return true;
}
}
// 声明同步器
private final sync sync = new sync();
// 加锁
public void lock() {
sync.acquire(1);
}
// 解锁
public void unlock() {
sync.release(1);
}
private static int count = 0;
public static void main(string[] args) throws interruptedexception {
mylockbaseonaqs lock = new mylockbaseonaqs();
countdownlatch countdownlatch = new countdownlatch(1000);
intstream.range(0, 1000).foreach(i -> new thread(() -> {
lock.lock();
try {
intstream.range(0, 10000).foreach(j -> {
count++;
});
} finally {
lock.unlock();
}
// system.out.println(thread.currentthread().getname());
countdownlatch.countdown();
}, "tt-" + i).start());
countdownlatch.await();
system.out.println(count);
}
}
运行main()方法总是打印出10000000（一千万），说明这个锁也是可以直接使用的，当然这也是一个不可重入的锁。
是不是很简单，只需要简单地实现aqs的两个方法就完成了上一章彤哥自己动手实现的锁的功能。
它是怎么实现的呢？
我们这一章先不讲源码，后面学习了reentrantlock自然就明白了。
这一章就到此结束了，本篇没有去深入的解析aqs的源码，笔者认为这没有必要，因为对于从来都没有看过锁相关的源码的同学来说，一上来就讲aqs的源码肯定会一脸懵逼的，具体的源码我们穿插在后面的锁和同步器的部分来学习，等所有跟aqs相关的源码学习完毕了，再来一篇总结。
下面总结一下这一章的主要内容：
（1）aqs是java中几乎所有锁和同步器的一个基础框架，这里说的是“几乎”，因为有极个别确实没有通过aqs来实现；
（2）aqs中维护了一个队列，这个队列使用双链表实现，用于保存等待锁排队的线程；
（3）aqs中维护了一个状态变量，控制这个状态变量就可以实现加锁解锁操作了；
（4）基于aqs自己动手写一个锁非常简单，只需要实现aqs的几个方法即可。
上一章彤哥自己动手写的锁，其实可以看成是aqs的一个缩影，看懂了那个基本上aqs可以看懂一半了，因为彤哥那个里面没有写condition相关的内容，下一章reentrantlock重入锁中我们将一起学习condition相关的内容。
所以呢，还是建议大家去看看这篇文章，点击下面的推荐阅读可以直达。
欢迎关注我的公众号“彤哥读源码”，查看更多源码系列文章, 与彤哥一起畅游源码的海洋。
如对本文有疑问， 点击进行留言回复！！
Springboot项目因为kackson版本问题启动报错解决方案
Java多线程下的其他组件之CyclicBarrier、Callable、Future和FutureTask详解
网友评论