队列同步器-AbstractQueuedSynchronizer

模板方法

这个队列同步器的设计就是基于模板方法

模板设计模式的定义：定义一个操作中的算法的框架，而将一些步骤延迟到子类中，使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

大致介绍

同步器依赖内部的同步队列(一个FIFO双向队列),来完成同步状态的管理,当前线程获取同步状态失败时,同步器会将当前线程以及等待信息放入到一个节点Node并将其加入同步队列,同时会阻塞当前线程,但同步状态释放时,会将首节点的线程唤醒,使其产生获取同步状态.

同步队列的节点(Node)用来保存获取同步状态失败的线程引用,等待状态以及前驱和后驱节点,结点的属性类型与名称以及描述.

static final class Node {
	//等待状态
	volatile int waitStatus;
	//前驱
	volatile Node prev;
	//后驱
	volatile Node next;
	//获取同步状态失败的线程引用
	volatile Thread thread;
	Node nextWaiter;
}

节点是构成同步队列的基础,同步器拥有首节点和尾结点,没有成功获取同步状态的线程将会加入该队列的尾部.

试想一下,一个线程获取同步状态成功,其他线程无法获取同步状态,转而去构造结点并加入同步队列,而加入队列必须是线程安全的(因为这个可能是竞争的,很多线程没获取到,然后竞争加入队列).同步器提供了基于CAS的设置尾结点的方法:compareAndSetTail(Node except,Node Update)

@Override
        protected boolean tryAcquire(int arg) {
            if(compareAndSetState(0,1)){
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }

上面这个是某个重写tryAcquire(int arg)方法的.

同步队列遵循FIFO.

独占式

获取同步状态

通过调用同步器的acquire(int arg)方法可以获取同步状态,该方法对中断不敏感,也就是由于线程获取同步状态失败后进入同步队列,后续对线程进行中断操作时,线程不会从同步队列中移除

  public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }
//该方法就是创建一个节点,然后试图去创建一个双向链表的尾结点
private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);
        // Try the fast path of enq; backup to full enq on failure
    	//此处可以看到,它在创建成功后会立刻尝试去加入尾结点,如果失败就会进入下面的enq的for循环里面
        Node pred = tail;
        if (pred != null) {
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        enq(node);
        return node;
    }
private Node enq(final Node node) {
        for (;;) {
            Node t = tail;
            if (t == null) { // Must initialize
                //如果首节点不存在,就创建它,
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
                //此处就是for循环插入为节点,CAS式必将并设置
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }
/**
     * Convenience method to interrupt current thread.
     阻塞当前线程
     */
    static void selfInterrupt() {
        Thread.currentThread().interrupt();
    }

 final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                //当前结点的前驱结点p,
                final Node p = node.predecessor();
                //如果p是头结点,并且尝试获取
                if (p == head && tryAcquire(arg)) {
                    //获取成功,将该结点设置为头结点
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                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;
    }

上述代码主要逻辑是:首先调用自定义同步器实现的tryAcquire(int arg)方法,该方法保证线程安全的获取同步状态,如果同步状态获取失败就构造一个同步节点(独占式的Node.EXCLUSIVE,同一时刻只有一个线程获取同步状态成功)并通过addWriter(Node node)方法将该结点加入同步队列尾部,最后调用acquireQueued(Node node,int arg),使得该结点以死循环方式获取通过状态.最后,如果获取不到同步状态,就阻塞结点中的线程,而被阻塞线程的唤醒主要依靠前驱结点的出队或阻塞线程被中断来实现.可以看出,enq(final Node node)方法将并发添加及诶到哪 的请求通过CAS变得""串行化

由于非首节点线程前驱结点出队或者被中断而从等待状态返回,随后检查自己的前驱是否是头结点,如果是就尝试获取同步状态.可以看出,节点和节点之间在循环检查中是互相不通信的,而正是检查自己的前驱是否是头结点,这样就可以使得节点的释放规则符合FIFO,并且也便于对过早通知的处理(过早通知是指前驱节点不是头结点的线程由于终端被唤醒)

同步器release方法

  public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }
    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)
            compareAndSetWaitStatus(node, 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 t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)
                    s = t;
        }
        if (s != null)
            LockSupport.unpark(s.thread);
    }

当前线程获取同步状态并执行相应逻辑之后,就需要释放同步方法,使得后续节点能够继续获取同步状态.通过调用同步器的relase(int arg)方法可以释放同步状态,该方法在释放了同步状态之后,会唤醒其后续节点.

分析了独占式同步状态获取和释放过程后，适当做个总结：在获取同步状态时，同步器维护一个同步队列，获取状态失败的线程都会被加入到队列中并在队列中进行自旋；移出队列（或停止自旋）的条件是前驱节点为头节点且成功获取了同步状态。在释放同步状态时，同步器调用tryRelease(int arg)方法释放同步状态，然后唤醒头节点的后继节点。

共享式

获取同步状态

public final void acquireShared(int arg) {
        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);
        }
    }

在acquireShared(int arg)方法中，同步器调用tryAcquireShared(int arg)方法尝试获取同步状态，tryAcquireShared(int arg)返回值是int类型，但返回值大于0就代表可以获取同步状态。因此在共享式获取的自旋过程中，成功获取到同步状态并退出自旋的条件就是tryAcquireShared(int arg)大于等于0

释放同步状态

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

释放同步状态一般是通过循环和cas来保证，因为释放同步状态的操作会同时来自多个线程。