AbstractQueuedSynchronizer

在不同模式等待的线程共用一个FIFO队列，子类实现独占模式或者共享模式不需要定义支持另一个模式的方法。

使用方法：通过使用getState，setState，和compareAndSetState方法来重写以下方法

①tryAcquire

②tryRelease

③tryAcquireShared

④tryReleaseShared

⑤isHeldExclusively

定义这些方法是使用这个类的唯一手段，因为其他方法都被定义为final。

实现公平锁：

如果方法hasQueuedPredecessors（特别为公平锁设计的方法）返回true，则方法tryAcquire返回false

示例用法：

class Mutex implements Lock, java.io.Serializable {
 
            // Our internal helper class
            private static class Sync extends AbstractQueuedSynchronizer {
      // Reports whether in locked state
              protected boolean isHeldExclusively() {
        return getState() == 1;
      }
 
              // Acquires the lock if state is zero
              public boolean tryAcquire(int acquires) {
        assert acquires == 1; // Otherwise unused
        if (compareAndSetState(0, 1)) {
          setExclusiveOwnerThread(Thread.currentThread());
          return true;
        }
        return false;
      }
 
              // Releases the lock by setting state to zero
              protected boolean tryRelease(int releases) {
        assert releases == 1; // Otherwise unused
        if (getState() == 0) throw new IllegalMonitorStateException();
        setExclusiveOwnerThread(null);
        setState(0);
        return true;
      }
 
              // Provides a Condition
              Condition newCondition() { return new ConditionObject(); }
 
              // Deserializes properly
              private void readObject(ObjectInputStream s)
          throws IOException, ClassNotFoundException {
        s.defaultReadObject();
        setState(0); // reset to unlocked state
      }
    }
 
            // The sync object does all the hard work. We just forward to it.
            private final Sync sync = new Sync();
 
            public void lock()                { sync.acquire(1); }
    public boolean tryLock()          { return sync.tryAcquire(1); }
    public void unlock()              { sync.release(1); }
    public Condition newCondition()   { return sync.newCondition(); }
    public boolean isLocked()         { return sync.isHeldExclusively(); }
    public boolean hasQueuedThreads() { return sync.hasQueuedThreads(); }
    public void lockInterruptibly() throws InterruptedException {
      sync.acquireInterruptibly(1);
    }
    public boolean tryLock(long timeout, TimeUnit unit)
        throws InterruptedException {
      return sync.tryAcquireNanos(1, unit.toNanos(timeout));
    }
  }

 

内部方法解释：

 

/**
* Wakes up node's successor, if one exists.
*
* @param node the node
*/
private void unparkSuccessor(Node node)

将当前节点的waitStatus < 0，则设置为0，唤醒下一个waitStatus<=0的线程

 

lock加锁操作：

调用acquire(1),该方法在AQS里：

/**
     * Acquires in exclusive mode, ignoring interrupts.  Implemented
     * by invoking at least once {@link #tryAcquire},
     * returning on success.  Otherwise the thread is queued, possibly
     * repeatedly blocking and unblocking, invoking {@link
     * #tryAcquire} until success.  This method can be used
     * to implement method {@link Lock#lock}.
     *
     * @param arg the acquire argument.  This value is conveyed to
     *        {@link #tryAcquire} but is otherwise uninterpreted and
     *        can represent anything you like.
     */
    public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

该方法先尝试获取锁，获取锁的动作就是使用CAS操作来设置state字段的值，如果成功则exclusiveOwnerThread字段设置为当前的线程对象。

如果尝试失败，则先构建一个EXCLUSIVE节点插入链表,然后执行acquireQueued方法：

/**
     * Acquires in exclusive uninterruptible mode for thread already in
     * queue. Used by condition wait methods as well as acquire.
     *
     * @param node the node
     * @param arg the acquire argument
     * @return {@code true} if interrupted while waiting
     */
    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);
        }
    }

该方法将当前线程park（阻塞），然后返回在阻塞前，当前线程的interrupted状态是否为true。（注：如果当前线程的interrupted==true的话，调用park不会阻塞线程，而是立即返回。而wait方法是抛出异常）

unlock解锁操作：

调用release方法：

/**
     * Releases in exclusive mode.  Implemented by unblocking one or
     * more threads if {@link #tryRelease} returns true.
     * This method can be used to implement method {@link Lock#unlock}.
     *
     * @param arg the release argument.  This value is conveyed to
     *        {@link #tryRelease} but is otherwise uninterpreted and
     *        can represent anything you like.
     * @return the value returned from {@link #tryRelease}
     */
    public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

从链表中找到一个节点线程唤醒。

这里只是说了个大概，并发编程时有许多细节需要考虑才能既做到并发安全又做到比较好的性能。