关于java:用火车购票的方式打开-AQS同步器一

5次阅读

共计 3571 个字符，预计需要花费 9 分钟才能阅读完成。

AQS（AbstractQueuedSynchronizer，下文间接应用 AQS 的简称）是 java JUC 包下提供的，基于 FIFO 队列，能够用于构建锁或者其余相干同步安装的根底框架，使用者能够继承它来实现阻塞锁或者其余性能。因为是一个框架，所以其概念会比拟形象，因而这里会应用乘火车车购票的例子来帮忙了解。

AQS 的三个重要的成员变量，其性能都是围绕这三个变量实现的。

  /**
     * Head of the wait queue, lazily initialized.  Except for
     * initialization, it is modified only via method setHead.  Note:
     * If head exists, its waitStatus is guaranteed not to be
     * CANCELLED.
     */
    private transient volatile Node head;

    /**
     * Tail of the wait queue, lazily initialized.  Modified only via
     * method enq to add new wait node.
     */
    private transient volatile Node tail;

    /**
     * The synchronization state.
     */
    private volatile int state;

State: 同步器的状态量。相似于火车对外发售的车票总数量。
head：期待队列的头节点。相似于车票售完后，第一个预约候补的人，能够了解为此时这人曾经再候补了。
tail：期待队列的尾节点。相似于所有预约候补的最初一个人。

而后来看看 Node 的构造是怎么样的？

// 状态：可能退出状态等
volatile int waitStatus;
// 后面的人
 volatile Node prev;
// 前面的人
 volatile Node next;
// 我本人
 volatile Thread thread;
/** 节点模式：排他或者共享 */
 Node nextWaiter;

waitStatus: 期待状态。AQS 提供四种状态：

CANCELLED：退出状态。相似购车票时，因为官网起因候补失败的人
SIGNAL：唤醒状态。正在候补或者候补实现，此时前面排队的人能够尝试候补了。
CONDITION：条件状态。这个是指在指定条件下，该乘客才会去预约候补（比方有紧急事务，必须明天去某地）
PROPAGATE：流传状态。对于排队的队列，能够共享候补的信息能够向后流传。

排他，是指资源被独占，此时其余线程无奈获取此资源，只能期待到以后资源被开释 （资源独享，比方买我了车票后，这辆火车就只有我能应用，其他人都不能应用），其原理次要是通过 tryAcquire 办法返回资源是否被占用，如果是就进入期待状态，如果否就执行当前任务。具体实现如下：

接下来来看看 AQS 提供的次要办法（排他和共享）
排他（资源独享，比方买我了车票后，这辆火车就只有我能应用，其他人都不能应用）：

 获取车票，没有获取到则进入期待
 public final void acquire(int arg) {if (!tryAcquire(arg) &&  // 尝试获取车票，因为是独占的，所以返回值间接应用 true or false
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))  // 没有买到车的人进行排队候补
            selfInterrupt(); // 是否自我中断（买车票的时候，总是抉择能够退票或者不买票了吧）}
    addWaiter(Node.EXCLUSIVE)：以排他模式退出到排队当中；

 尝试获取车票，否则期待
final boolean acquireQueued(final Node node, int arg) { // 期待唤醒
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {final Node p = node.predecessor();  // 排在本人后面的人
                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 static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;
        if (ws == Node.SIGNAL) // 后面的人曾经是唤醒状态，正在期待有车票的时候
            /*
             * This node has already set status asking a release
             * to signal it, so it can safely park.
             */
            return true;  // 本人能够挂起了，只有期待有车票的时候会告诉本人
        if (ws > 0) {  // 将排在本人后面退出状态的人都剔除
            /*
             * Predecessor was cancelled. Skip over predecessors and
             * indicate retry.
             */
            do {node.prev = pred = pred.prev;} while (pred.waitStatus > 0);
            pred.next = node;
        } else {
            /*
             * waitStatus must be 0 or PROPAGATE.  Indicate that we
             * need a signal, but don't park yet.  Caller will need to
             * retry to make sure it cannot acquire before parking.
             */
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL); // 将排在后面的人改为须要唤醒状态
                                                                                 // 并再给一次机会去获取车票
        }
        return false;  // 本人不须要挂起
    }

开释资源：

 开释资源（其中有人退票了或者下车了，又有空余的车票了，就告诉队列里的人能够尝试候补）：public final boolean release(int arg) {if (tryRelease(arg)) {  // 本人退票或下车，有空余的车票了
            Node h = head;  // 候补队列中第一人
            if (h != null && h.waitStatus != 0)   // 存在 并且状态曾经不是 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);  // 将状态设置为 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); // 告诉排在前面且没有退出的人，能够起来关注候补状况了（acquireQueued）}

正文完