AQS(AbstractQueuedSynchronizer)队列同步器源码阅读(二)

·  阅读 196

续上一篇文章: juejin.cn/post/684490…

共享式同步状态获取与释放

共享式获取与独占式获取最主要的区别在于同一时刻能否有多个线程同时获取到同步状态。以文件的读写为例,如果一个程序在对文件进行读操作,那么这一时刻对于该文件的写操作均被阻塞,而读操作能够同时进行。写操作要求对资源的独占式访问,而读操作可以是共享式访问,两种不同的访问模式在同一时刻对文件或资源的访问情况,如图:

共享式与独占式访问资源的对比

左半部分,共享式访问资源时,其他共享式的访问均被允许,而独占式访问被 阻塞,右半部分是独占式访问资源时,同一时刻其他访问均被阻塞。

通过调用同步器的acquireShared(int arg)方法可以共享式地获取同步状态,该方法代码如:

public final void acquireShared(int arg) {
//tryAcquireShared(int arg)方法返回值为int类型,当返回值大于等于0时,表示能够获取到同步状态。
//这里tryAcquireShared这个方法也是一个给子类重写的方法,一般是给读写锁中的读锁中可以共享的进行读,
//这时候需要重写共享获取同步状态的方法,如果获取成功,则返回值大于等于0,否则,执行doAcquireShared,进行自旋的共享获取同步状态
        if (tryAcquireShared(arg) < 0)
            doAcquireShared(arg);
    }

private void doAcquireShared(int arg) {

        final Node node = addWaiter(Node.SHARED);
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor();
                if (p == head) {
                    int r = tryAcquireShared(arg);
                    if (r >= 0) {
                        setHeadAndPropagate(node, r);
                        p.next = null; // help GC
                        if (interrupted)
                            selfInterrupt();
                        failed = false;
                        return;
                    }
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }
复制代码

在doAcquireShared(int arg)方法的自旋过程中,如果当前节点的前驱为头节点时,尝试获取同步状态,如果返回值大于等于0,表示该次获取同步状态成功并从自旋过程中退出。与独占式一样,共享式获取也需要释放同步状态,通过调用releaseShared(int arg)方法可以释放同步状态,

public final boolean releaseShared(int arg) {
  if (tryReleaseShared(arg)) {
    doReleaseShared();
    return true;
  }
  return false;
}
复制代码

该方法在释放同步状态之后,将会唤醒后续处于等待状态的节点。对于能够支持多个线程同时访问的并发组件(比如Semaphore),它和独占式主要区别在于tryReleaseShared(int arg)方法必须确保同步状态(或者资源数)线程安全释放,一般是通过循环和CAS来保证的,因为释放同步状态的操作会同时来自多个线程。

//释放共享锁,通知后续节点
private void doReleaseShared() {
//自旋
    for (;;) {
        Node h = head;
        if (h != null && h != tail) {   
            int ws = h.waitStatus;
            if (ws == Node.SIGNAL) {   //signal为-1,表示后续节点的线程处于等待状态,当前节点的线程
                                      //如果释放了同步状态或者被取消,将会通知后续节点
                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))  //将节点状态设置为0
                    continue;            // loop to recheck cases
                unparkSuccessor(h);//唤醒后续节点
            }
            //waitStatus为0时代表初始状态,设置为-3表示下一次同步状态的获取将
                                                //表示下一次共享式同步状态获取将会无条件传播下去
            else if (ws == 0 &&
                     !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                continue;                // loop on failed CAS
        }
        if (h == head)                   // loop if head changed
            break;
    }
}
复制代码

这段方法跟独占式锁释放过程有点点不同,在共享式锁的释放过程中,对于能够支持多个线程同时访问的并发组件,必须保证多个线程能够安全的释放同步状态,这里采用的CAS保证,当CAS操作失败continue,在下一次循环中进行重试。

可中断(acquireSharedInterruptibly()方法)

public final void acquireSharedInterruptibly(int arg)
            throws InterruptedException {
//如果线程已经中断,抛出异常
        if (Thread.interrupted())
            throw new InterruptedException();
//否则尝试共享式获取同步状态,获取失败,则调用doAcquireSharedInterruptibly方法。
        if (tryAcquireShared(arg) < 0)
            doAcquireSharedInterruptibly(arg);
    }

 private void doAcquireSharedInterruptibly(int arg)
        throws InterruptedException {
//加入同步等待队列,状态设置为共享
        final Node node = addWaiter(Node.SHARED);
        boolean failed = true;
        try {
            for (;;) {
                //获取当前节点的前驱节点
                final Node p = node.predecessor();
              //如果为head节点 ,说明这是第一个。
              if (p == head) {
                    int r = tryAcquireShared(arg);   //如果共享获取同步状态成功
                  //如果获取到同步状态,设置头节点出队列,并唤醒下一个 ,传播
                  if (r >= 0) {
                        setHeadAndPropagate(node, r);
                        p.next = null; // help GC
                        failed = false;
                        return;
                    }
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }

//设置队列头,并检查后继者是否在共享模式下等待*,如果是则传播下一个,如果传播> 0或* PROPAGATE状态已设置。
private void setHeadAndPropagate(Node node, int propagate) {
        Node h = head; // Record old head for check below
        setHead(node);
     //
        if (propagate > 0 || h == null || h.waitStatus < 0 ||
            (h = head) == null || h.waitStatus < 0) {
            Node s = node.next;
            if (s == null || s.isShared())
                doReleaseShared();
        }
    }
复制代码

超时等待(tryAcquireSharedNanos()方法)

public final boolean tryAcquireSharedNanos(int arg, long nanosTimeout)
            throws InterruptedException {
        if (Thread.interrupted())
            throw new InterruptedException();
        return tryAcquireShared(arg) >= 0 ||
            doAcquireSharedNanos(arg, nanosTimeout);
    }

private boolean doAcquireSharedNanos(int arg, long nanosTimeout)
            throws InterruptedException {
        if (nanosTimeout <= 0L)
            return false;
        final long deadline = System.nanoTime() + nanosTimeout;
        final Node node = addWaiter(Node.SHARED);
        boolean failed = true;
        try {
            for (;;) {
                final Node p = node.predecessor();
                if (p == head) {
                    int r = tryAcquireShared(arg);    //区别
                    if (r >= 0) {
                        setHeadAndPropagate(node, r);
                        p.next = null; // help GC
                        failed = false;
                        return true;
                    }
                }
                nanosTimeout = deadline - System.nanoTime();
                if (nanosTimeout <= 0L)
                    return false;
                if (shouldParkAfterFailedAcquire(p, node) &&
                    nanosTimeout > spinForTimeoutThreshold)
                    LockSupport.parkNanos(this, nanosTimeout);
                if (Thread.interrupted())
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }
复制代码

逻辑与独占式获取锁差不多,区别就是获取同步状态时共享式获取的。其余几乎一致。

待续。。。。

分类:
后端
标签:
分类:
后端
标签:
收藏成功!
已添加到「」, 点击更改