JAVA进阶之路-AbstractQueuedSynchronizer(AQS)源码走读

1.AQS介绍

AbstractQueuedSynchronizer是JUC的lock包实现的基石,内部通过一个int成员变量表示同步状态,也有一个是通过long实现的版本,但是int基本够用。这个state被volatile修饰保证了各个线程之间的可见性。内部通过一个内置的FIFO队列来完成资源获取线程的排队工作。
内部状态state和等待队列的head和尾节点tail通过使用volatile关键字修饰,保证了内存之间的可见性。

子类通过重写tryAcquire和tryRelease抑或tryAcquireShared和tryReleaseShared,通过CAS修改状态state。(CAS是由unsafe提供的硬件级别支持的原子操作,compareAndSet,通过lock前缀指令,cmpxchg指令实现)。
内部的CLH队列由定义Node构成,如下

Node {
   int waitStatus;//节点状态,状态如下:
                  //CANCELLED,值为1,表示当前的线程被取消
                  //SIGNAL,值为-1,表示当前节点的后继节点包含的线程需要运行
                  //CONDITION,值为-2,表示当前节点在等待condition,也就是在condition队列中
                  //PROPAGATE,值为-3,表示当前场景下后续的acquireShared能够得以执行
                  //值为0,表示当前节点在sync队列中,等待着获取锁。
   Node prev;//前驱节点
   Node next;//后继节点
   Node nextWaiter;//条件队列里的节点
   Thread thread;//当前线程
}

上面就是大致node节点的属性特征,下面来大概描述下整个的交互过程。

2.AQS获取锁的过程

先看一个代码执行的实例

public class AbstractQueuedSynchronizerTest {


    private static final Lock lock = new ReentrantLock();
    public static void main(String[] args) throws Exception{

        ExecutorService executorService = Executors.newFixedThreadPool(2);


        executorService.submit(AbstractQueuedSynchronizerTest::action);
        executorService.submit(AbstractQueuedSynchronizerTest::action);

        executorService.awaitTermination(200, TimeUnit.SECONDS);
        executorService.shutdown();

    }


    private static void action() {
        System.out.printf("当前线程[%s],正在等待您的输入",Thread.currentThread().getName());

            lock.lock();
        try {
            System.in.read();
            System.out.printf("当前线程[%s],执行完毕",Thread.currentThread().getName());

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

}

上面的流程是定义了一个固定大小为2的线程池,然后提交了两个执行任务,等待读取控制台,然后最后释放锁。下面来进行编号,加入两个线程的名称分别是Thread1和Thread2.

lock获取锁的过程

  public void lock() {
  //每次获取锁都+1的方式来竞争
        sync.acquire(1);
    }
    
    //获取锁的过程
 public final void acquire(int arg) {
 
 //首先尝试获取锁
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

//加入上述走的是非公平锁的流程
  @ReservedStackAccess
        final boolean nonfairTryAcquire(int acquires) {
        //获取当前线程
            final Thread current = Thread.currentThread();
            //获取state的状态,初始值是0,0代表就可以进行竞争锁
            int c = getState();
            //如果state等于0,就可以尝试获取锁
            if (c == 0) {
            //cas的方式把stage更新设置为1
                if (compareAndSetState(0, acquires)) {
                //如果设置成功后,设置当前线程标识,代表当前线程已经拿到锁了,可重入锁的时候需要用到
                    setExclusiveOwnerThread(current);
                    //直接返回true
                    return true;
                }
            }
            //如果state不等于0,判断当前的线程是不是又要再次获取锁,如果当前线程持有该锁了,要再次获取的话,就不需要获取了,可重入锁的概念
            else if (current == getExclusiveOwnerThread()) {
            //可重入锁也对stage+1,这块是线程安全的,该线程已经持有了锁,所以可以随意操作state
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                    //设置当前的状态值,这块是线程安全的,该线程已经持有了锁,所以可以随意操作state
                setState(nextc);
                return true;
            }
            //如果多个线程竞争,既没有更新state,也不是可重入的线程,直接返回false
            return false;
        }

//自旋的方式来获取锁
final boolean acquireQueued(final Node node, int arg) {
//中断响应是false
        boolean interrupted = false;
        try {
        //自旋的方式来获取锁
            for (;;) {
            //获取当前节点的前一个节点
                final Node p = node.predecessor();
                //如果前一个节点是头节点的话,就先尝试获取锁一次,这里因为,如果之前的线程执行完了的话,也就是头节点的线程执行完毕的话,这里是可以直接获取到锁的,做了一点点的优化
                if (p == head && tryAcquire(arg)) {
                //如果前一个节点是头节点的话,获取到锁了,代表头节点执行完毕释放锁了
                //重新设置当前节点是head节点
                    setHead(node);
                    //去除调用链,help GC
                    p.next = null; // help GC
                    //没有被中断,所以返回false
                    return interrupted;
                }
//
//获取锁失败后,并不是立即阻塞,需要检查该线程的状态,该方法主要依靠前驱节点判断当前线程是否应该被阻塞
                if (shouldParkAfterFailedAcquire(p, node))
                //如果是阻塞的话,直接调用阻塞方法阻塞
                    interrupted |= parkAndCheckInterrupt();
            }
        } catch (Throwable t) {
            cancelAcquire(node);
            if (interrupted)
                selfInterrupt();
            throw t;
        }
    }

//建立CLH队列,通过自旋的方式,也就是一个for(;;)的方式
private Node addWaiter(Node mode) {
        Node node = new Node(mode);

        for (;;) {
        //如果是第一个线程进入的,那么tail是null,就会进行初始化操作
        //如果已经初始化了,那么就向尾部添加
            Node oldTail = tail;
            if (oldTail != null) {
            //设置当前节点的前一个节点是尾部节点
                node.setPrevRelaxed(oldTail);
                //cas原理更新当前节点是尾部节点,如果更新成功
                if (compareAndSetTail(oldTail, node)) {
                //如果更新成功,由于是双向链表,把之前尾部的下一个节点设置为新加的节点
                    oldTail.next = node;
                    return node;
                }
            } else {
            //如果是首次的话,就直接初始化
                initializeSyncQueue();
            }
        }
    }

//首次初始化头节点和尾部节点
private final void initializeSyncQueue() {
        Node h;
        //cas原理设置头部节点和尾部节点
        if (HEAD.compareAndSet(this, null, (h = new Node())))
            tail = h;
    }

//这段代码主要检查当前线程是否需要被阻塞,具体规则如下:

/*如果当前线程的前驱节点状态为SINNAL,则表明当前线程需要被阻塞,调用unpark()方法唤醒,直接返回true,当前线程阻塞
如果当前线程的前驱节点状态为CANCELLED(ws > 0),则表明该线程的前驱节点已经等待超时或者被中断了,则需要从CLH队列中将该前驱节点删除掉,直到回溯到前驱节点状态 <= 0 ,返回false
如果前驱节点非SINNAL,非CANCELLED,则通过CAS的方式将其前驱节点设置为SINNAL,返回false */
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        //前驱节点
        int ws = pred.waitStatus;
        //状态为signal,表示当前线程处于等待状态,直接放回true
        if (ws == Node.SIGNAL)
            return true;
        //前驱节点状态 > 0 ,则为Cancelled,表明该节点已经超时或者被中断了,需要从同步队列中取消
        if (ws > 0) {
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        }
        //前驱节点状态为Condition、propagate
        else {
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }

上述就是整个获取锁的过程,总之就是通过自旋获取锁,直至异常退出或获取锁成功,但是并不是busy acquire,因为当获取失败后会被挂起,由前驱节点释放锁时将其唤醒。同时由于唤醒的时候可能有其他线程竞争,所以还需要进行尝试获取锁,体现的非公平锁的精髓。

unlock释放锁的过程

//释放锁,对state进行减1操作
 public void unlock() {
        sync.release(1);
    }

//释放锁的过程
 public final boolean release(int arg) {
        if (tryRelease(arg)) {
        //如果释放锁成功
            Node h = head;
            //判断当前头节点的状态
            if (h != null && h.waitStatus != 0)
            //唤醒下一个节点
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

 /**
     * Wakes up node's successor, if one exists.
     *
     * @param node the node
     */
    private void unparkSuccessor(Node node) {
        /*
         * If status is negative (i.e., possibly needing signal) try
         * to clear in anticipation of signalling.  It is OK if this
         * fails or if status is changed by waiting thread.
         */
        int ws = node.waitStatus;
        if (ws < 0)
            node.compareAndSetWaitStatus(ws, 0);

        /*
         * Thread to unpark is held in successor, which is normally
         * just the next node.  But if cancelled or apparently null,
         * traverse backwards from tail to find the actual
         * non-cancelled successor.
         */
        Node s = node.next;
        if (s == null || s.waitStatus > 0) {
            s = null;
            for (Node p = tail; p != node && p != null; p = p.prev)
                if (p.waitStatus <= 0)
                    s = p;
        }
        if (s != null)
            LockSupport.unpark(s.thread);
    }

//尝试释放锁的流程
 protected final boolean tryRelease(int releases) {
 
 //对当前的stage进行减1操作
            int c = getState() - releases;
            //如果unlock的时候,当前线程不是占有锁的线程,抛出异常
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
                //定义变量是否释放锁标识
            boolean free = false;
            //如果c已经变为0了,代表锁已经被释放掉了
            if (c == 0) {
            //free变为true
                free = true;
                //释放当前占有锁的变量
                setExclusiveOwnerThread(null);
            }
            //如果c不等于0,可能是有可重入锁的场景,可重入锁,当前线程占有了锁,再次获取锁的时候,进行了加1操作,所以减少完后可能还是有可重入锁的存在
            setState(c);
            return free;
        }

总结

1.整个获取锁的过程,通过控制state变量,如果是0,则代表当前已经没有锁,如果是1则代表,获取锁变量成功,后续没有竞争获取锁的线程,会包装成node节点加入到CLH的阻塞队列中,并通过自旋的方式,一直判断自己的前一个节点是否是头节点,是的话就尝试获取锁,否则就阻塞。
2.释放锁的过程,直接对state进行减1操作,然后判断是否是0,如果是0的话,就释放当前的线程标识即可,释放成功后,就唤醒阻塞中的后续节点

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页