摘要:文章目录简介核心源码主要内部类主要属性子类需要实现的主要方法基于自己动手写一个锁总结简介的全称是,它的定位是为中几乎所有的锁和同步器提供一个基础框架。
AQS的全称是AbstractQueuedSynchronizer,它的定位是为Java中几乎所有的锁和同步器提供一个基础框架。
AQS是基于FIFO的队列
实现的,并且内部维护了一个状态变量state,通过原子更新这个状态变量state
即可以实现加锁解锁操作。
可以先参考一下【JDK源码】同步系列手写Lock,这个Lock其实可以看成是AQS的一个缩影
static final class Node { // 标识一个节点是共享模式 shared static final Node SHARED = new Node(); // 标识一个节点是互斥模式 exclusive static final Node EXCLUSIVE = null; // 标识线程已取消 cancelled static final int CANCELLED = 1; // 标识后继节点需要唤醒 signal static final int SIGNAL = -1; // 标识线程等待在一个条件上 condition 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的方法原子更新stateprotected final boolean compareAndSetState(int expect, int update) { return unsafe.compareAndSwapInt(this, stateOffset, expect, update);}
关于Unsafe类可以参考【JDK源码】魔法类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();}// 如果当前线程独占着锁,返回trueprotected boolean isHeldExclusively() { throw new UnsupportedOperationException();}
这几个方法为什么不直接定义成抽象方法呢?
因为子类只要实现这几个方法中的一部分就可以实现一个同步器了,所以不需要定义成抽象方法。
直接上代码:
public class Demo17 { // 定义一个同步器,实现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() { // 调用AQS方法 sync.acquire(1); } /* public final void acquire(int arg) { 再次调用tryAcquire方法,由于我们重写了 所以会走我们的tryAcquire方法 if (!tryAcquire(arg)) acquire(null, arg, false, false, false, 0L); } */ // 解锁 和acquire原理一样 public void unlock() { sync.release(1); } private static int count = 0; public static void main(String[] args) throws InterruptedException { Demo17 lock = new Demo17(); for (int i = 0; i < 1000; i++) { new Thread(new Runnable() { @Override public void run() { lock.lock(); for (int i1 = 0; i1 < 10000; i1++) { count++; } lock.unlock(); } }).start(); } Thread.sleep(3000); System.out.println(count); }}
运行main()方法总是打印出10000000,说明这个锁也是可以直接使用的,当然这也是一个不可重入的锁(因为tryAcquire失败就直接失败了,没有判断是否是当前线程占有锁)
(1)AQS是Java中几乎所有锁和同步器的一个基础框架,这里说的是“几乎”,因为有极个别确实没有通过AQS来实现;
(2)AQS中维护了一个队列,这个队列使用双链表实现,用于保存等待锁排队的线程;
(3)AQS中维护了一个状态变量,控制这个状态变量就可以实现加锁解锁操作了;
(4)基于AQS自己动手写一个锁非常简单,只需要实现AQS的几个方法即可。
文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。
转载请注明本文地址:https://www.ucloud.cn/yun/123458.html
摘要:在时,引入了包,该包中的大多数同步器都是基于来构建的。框架提供了一套通用的机制来管理同步状态阻塞唤醒线程管理等待队列。指针用于在结点线程被取消时,让当前结点的前驱直接指向当前结点的后驱完成出队动作。 showImg(https://segmentfault.com/img/remote/1460000016012438); 本文首发于一世流云的专栏:https://segmentfau...
摘要:表示的是两个,当其中任意一个计算完并发编程之是线程安全并且高效的,在并发编程中经常可见它的使用,在开始分析它的高并发实现机制前,先讲讲废话,看看它是如何被引入的。电商秒杀和抢购,是两个比较典型的互联网高并发场景。 干货:深度剖析分布式搜索引擎设计 分布式,高可用,和机器学习一样,最近几年被提及得最多的名词,听名字多牛逼,来,我们一步一步来击破前两个名词,今天我们首先来说说分布式。 探究...
摘要:简介抽象队列同步器,以下简称出现在中,由大师所创作。获取成功则返回,获取失败,线程进入同步队列等待。响应中断版的超时响应中断版的共享式获取同步状态,同一时刻可能会有多个线程获得同步状态。 1.简介 AbstractQueuedSynchronizer (抽象队列同步器,以下简称 AQS)出现在 JDK 1.5 中,由大师 Doug Lea 所创作。AQS 是很多同步器的基础框架,比如 ...
阅读 2331·2021-11-18 10:02
阅读 1553·2021-11-16 11:44
阅读 2129·2021-09-30 09:47
阅读 1467·2021-09-27 14:01
阅读 2941·2021-08-16 11:00
阅读 3061·2019-08-30 11:06
阅读 2295·2019-08-29 17:29
阅读 1371·2019-08-29 13:19