AQS原理详解

最新推荐文章于 2024-01-11 13:12:03 发布

尚凯辉的博客

最新推荐文章于 2024-01-11 13:12:03 发布

阅读量258

点赞数

分类专栏：多线程文章标签： java

本文链接：https://blog.csdn.net/kaihuishang666/article/details/117934813

版权

多线程专栏收录该内容

10 篇文章 0 订阅

订阅专栏

文章目录

定义

AQS:抽象队列同步器

AQS是用来构建锁或者其他同步器组件的基础框架，是整个JUC体系的基石。

AQS使用一个volatile修饰的int类型的成员变量state表示同步状态（0表示无锁，大于0表示持有锁），和一个先进先出的双向链表队列来完成阻塞线程的排队工作。线程会被封装成Node节点，如果线程抢不到锁，就会加入队列尾部进行排队，State的状态是通过CAS来修改的。

原理

核心思想是当多个线程竞争资源时会将未成功竞争到资源的线程构造为 Node 节点放置到一个双向 FIFO 队列中。被放入到该队列中的线程会保持阻塞直至被前驱节点唤醒。值得注意的是该队列中只有队列头节点才有资格去唤醒竞争线程去竞争锁。

主要是通过CAS,自旋以及Locksupport.park等方式，达到同步的控制效果。

加锁流程

首先线程会尝试获取锁，如果获取锁成功，则通过cas将state从0改为1。
如果当前线程获取锁失败，则将当前线程封装成Node节点，通过CAS将队列加入尾部
加入队列尾部后，通过LockSupport.park阻塞当前线程
同步状态被释放并且同步器重新设置首节点，同步器唤醒等待队列中第一个节点，让其再次获取同步状态

解锁流程

线程尝试解锁，如果解锁成功，将state从1改为0,设置exclusiveOwnerThread=null。
获取队列的头节点，通过cas将头结点的waitstatus改为0。
获取头节点的下一节点，通过LockSupport.unpark唤醒线程。

流程图

ReentrankLock原理

当前线程调用自定义同步器实现的tryAcquire方法，该方法保证线程安全的获取同步状态，如果同步状态获取失败，则执行后续流程
构造独占式同步节点，通过调用addWaiter方法将Node塞入同步队列尾部，并且调用acquireQueued方法自旋获取同步锁状态，如果获取不到，则阻塞当前线程。

加锁代码

lock

static final class NonfairSync extends Sync {
    final void lock() {
   			//首先是通过CAS的方式抢占锁，如果抢占成功则将state的值设置为1。然后将对象独占线程设置为当前线程。
        if (compareAndSetState(0, 1))
            setExclusiveOwnerThread(Thread.currentThread());
        else
           //如果失败，则调用acquire
            acquire(1);
    }
}

acquire

public abstract class AbstractQueuedSynchronizer{
	
  public final void acquire(int arg) {
      if (!tryAcquire(arg) &&
          acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
          selfInterrupt();
  }
}

acquire 方法用于获取锁，这里可以拆解为三步：

tryAcquired：尝试获取锁，并不保证一定可以获取锁，具体逻辑由子类实现。如果在这一步成功获取到了锁，后面的逻辑也就没有必要继续执行了。
addWaiter：尝试竞争锁资源失败后，将当前线程包装成一个 Node 节点后，加入到双向队列的尾部。
acquireQueued：自旋获取同步锁状态，如果获取不到，则阻塞当前线程。线程被唤醒后，会继续尝试获取锁。

tryAcquire

static final class NonfairSync extends Sync {
  protected final boolean tryAcquire(int acquires) {
      return nonfairTryAcquire(acquires);
  }
  final boolean nonfairTryAcquire(int acquires) {
       final Thread current = Thread.currentThread();
       int c = getState();// 获取state值
       if (c == 0) { 
       // 如果state值为0，说明无锁，那么就通过cas方式，尝试加锁，成功后将独占线程设置为当前线程
           if (compareAndSetState(0, acquires)) {
               setExclusiveOwnerThread(current);
               return true;
           }
       }
       else if (current == getExclusiveOwnerThread()) { // 如果是同一个线程再次来获取锁，那么就将state的值进行加1处理（可重入锁的，重入次数）。
           int nextc = c + acquires;
           if (nextc < 0) // overflow
               throw new Error("Maximum lock count exceeded");
           setState(nextc);
           return true;
       }
       return false;
   }
}

addWaiter


private Node addWaiter(Node mode) {
    // 将当前线程包装成一个 Node 节点
    Node node = new Node(Thread.currentThread(), mode);
    Node pred = tail;
    // 如果 tail 节点不为空，通过CAS让新节点成为新的尾节点，新节点的前驱指向 tail，原尾节点的后继指向当前节点
    if (pred != null) {
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    // 第一次往队列中新增节点时，会执行 enq 方法
    enq(node);
    return node;
}
private Node enq(final Node node) {
    for (;;) {
     // head 和 tail 在初始情况下都为 null,此时会先初始化一个空节点作为傀儡节点
        Node t = tail;
        if (t == null) { // 如果尾节点为空说明，队列为空，初始化一个空节点作为傀儡节点，用于帮助唤醒队列中的第一个有效线程
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            // 这段逻辑用于考虑多线程并发的场景，如果此时队列中已经有了节点
            // 再次尝试将当前节点插至队尾
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

当我们处理第一个节点时，此时 tail 节点为 null，因此会执行 enq() 方法。可以看到 enq 方法实际是一个死循环，只有当节点成功被插入到队列后，才能跳出去循环。那这么做的目的是什么呢？其实不难看出，这里是为了应对多线程竞争而采取的妥协之策。多个线程同时执行这段逻辑时，只有一个线程可以成功调用 compareAndSetHead() 并将 head 头指向一个新的节点，此时的 head 和 tail 都指向一个空节点。这个空节点就是傀儡节点，用于唤醒后续的节点。其它并发执行的线程执行 compareAndSetHead() 方法失败后，发现 tail 已经不为 null 了，依次将自己插入到 tail 节点后。
当 tail 节点不为空时，表示此时队列中有数据。因此我们借助 CAS 将新节点插入到尾节点之后，同时将 tail 指向新节点。
通过addWaiter方法，节点就一定被加入到队列尾部了。

addWaiter()中主要做了三件事：

将当前线程封装成Node。
判断队列中尾部节点是否为空，若不为空，则将当前线程的Node节点通过CAS插入到尾部。
如果尾部节点为空或CAS插入失败则通过enq()方法插入到队列中。

acquireQueued


final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
            final Node p = node.predecessor();
            // 前驱节点为 head 时，尝试获取锁
            if (p == head && tryAcquire(arg)) {
            		//抢占锁成功，当前节点成功新的head节点
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            //如果当前节点不为head,或者抢占锁失败。就根据节点的状态waitStatus决定是否需要挂起线程。
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

   private void setHead(Node node) {
        head = node;
        node.thread = null;
        node.prev = null;
    }

这里又是一个死循环

这里需要注意的是只有前驱节点为 head 时，我们才会再次尝试获取锁。如果成功获取到了锁：将 node 节点设置为头节点，同时将前驱节点的 next 设置为 null 帮助 gc。
如果 node 节点前驱节点不为 head 或者获取锁失败，执行 shouldParkAfterFailedAcquire() 方法判断当前线程是否需要阻塞，如果需要阻塞则会调用 parkAndCheckInterrupt() 方法挂起当前线程

shouldParkAfterFailedAcquire


private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL) //-1
        /*
         * 当前驱节点状态为 SIGNAL 时，表示调用 release 释放前驱节点占用的锁时，
         * 前驱会唤醒当前节点，可安全挂起当前线程等待被唤醒
         */
        return true;
    if (ws > 0) {
        /*
         * 前驱节点处于取消状态，我们需要跳过这个节点，并且重试
         */
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        // waitStatus 为 0 或 PROPAGATE 走的这里。
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

  private final boolean parkAndCheckInterrupt() {
        //通过 LockSupport.park阻塞当前线程，线程被unpark后，会被唤醒，继续尝试获取锁
        LockSupport.park(this);
        return Thread.interrupted();
    }

当节点状态为 SIGNAL 时，表示当前线程可以被安全挂起。waitStats 大于0表示当前线程已经被取消，我们需要往前回溯找到有效节点。

释放锁代码

release


public final boolean release(int arg) {
		// 尝试释放资源
    if (tryRelease(arg)) {
        Node h = head;
        //释放成功后，判断头节点的状态是否为无锁状态，如果不为无锁状态就将头节点中的线程唤醒。
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    // 释放资源失败，直接返回false
    return false;
}


protected final boolean tryRelease(int releases) {
		// 从state中减去传入参数的相应值（一般为1）
    int c = getState() - releases;
    // 当释放资源的线程与独占锁现有线程不一致时，非法线程释放，直接抛出异常。
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    // 这里是处理重入锁的机制，因为可重入机制，所以每次都重入state值都加1，
    //所以在释放的时候也要相应的减1，直到state的值为0才算完全的释放锁资源。
    if (c == 0) {
        free = true;
        // 完全释放资源后，将独占线程设置为null,这样后面的竞争线程才有可能抢占。
        setExclusiveOwnerThread(null);
    }
    // 重新赋值state
    setState(c);
    return free;
}


private void unparkSuccessor(Node node) {
		//注意：此时node是头结点，获取头结点状态
    int ws = node.waitStatus;
    if (ws < 0)
        // 当状态小于 0 时，更新 waitStatus 值为 0
        compareAndSetWaitStatus(node, ws, 0);
    //获取下一个需要唤醒的节点线程。 
    Node s = node.next;
    // 如果后继节点为 null 或者状态为取消，从尾结点向前查找状态不为取消的可用节点
    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);
}

尚凯辉的博客

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
AQS原理详解

文章目录定义原理加锁流程解锁流程流程图ReentrankLock原理加锁代码lockacquiretryAcquireaddWaiteracquireQueuedshouldParkAfterFailedAcquire释放锁代码release定义AQS:抽象队列同步器AQS是用来构建锁或者其他同步器组件的基础框架，是整个JUC体系的基石。AQS使用一个volatile修饰的int类型的成员变量state表示同步状态（0表示无锁，大于0表示持有锁），和一个先进先出的双向链表队列来完成阻塞线程的排队工作
复制链接

扫一扫