多线程同步工具——Lock

本文原创，转载请注明出处。

参考文章：

《“JUC锁”03之 公平锁(一)》

《“JUC锁”03之 公平锁(二)》

锁分独占锁与共享锁，公平锁与非公平锁，悲观锁与乐观锁，可重入锁与不可重入锁，相关概念可查看其它文章。

Lock操作：加锁（lock），解锁（unlock），创建条件对象（newCondition）。

Condition操作：等待（await），通知（signal）。

ReentrantLock：是一个可重入锁，独占锁，由构造参数决定是公平锁还是非公平锁。

ReadWriteLock的操作就是获取读取锁与改写锁。

ReentrantReadWriteLock：它的读取锁与改写锁都是可重入锁，并且由构造参数决定是公平锁还是非公平锁。

StampedLock：是Java8增加的锁，它不支持重入，也不支持Condition。相关文章《深入理解StampedLock及其实现原理》

ReentrantLock的源码分析：

/**
 * @since 1.5
 * @author Doug Lea
 */
public class ReentrantLock implements Lock, java.io.Serializable {
    private static final long serialVersionUID = 7373984872572414699L;

    private final Sync sync;

    public ReentrantLock() {
        // 默认使用非公平锁
        sync = new NonfairSync();
    }

    public ReentrantLock(boolean fair) {
        // 由参数决定使用公平锁还是非公平锁
        sync = fair ? new FairSync() : new NonfairSync();
    }

    abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -5179523762034025860L;

        abstract void lock();

        final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            // 判断锁是否未被持有
            if (c == 0) {
                // 尝试占用锁
                if (compareAndSetState(0, acquires)) {
                    // 占用成功后，更新锁所属线程为当前线程
                    setExclusiveOwnerThread(current);
                    // 返回占用成功
                    return true;
                }
            }
            // 如果锁已被占用，判断当前线程是否持有锁
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                // 不允许锁被释放，否则视为系统错误
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                // 更新锁的持有次数
                setState(nextc);
                // 返回占用成功
                return true;
            }
            // 返回占用失败
            return false;
        }

        protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            // 不允许当前线程释放其它线程持有的锁，否则抛出异常
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            // 判断锁是否达到释放值
            if (c == 0) {
                // 标记锁需要释放
                free = true;
                // 清空锁的所属线程
                setExclusiveOwnerThread(null);
            }
            // 更新锁的持有次数
            setState(c);
            // 返回锁是否达到释放值而被释放，否则未释放。
            return free;
        }

        protected final boolean isHeldExclusively() {
            // 返回当前线程是否持有锁
            return getExclusiveOwnerThread() == Thread.currentThread();
        }

        final Thread getOwner() {
            // 返回锁所属线程
            return getState() == 0 ? null : getExclusiveOwnerThread();
        }

        final int getHoldCount() {
            // 如果当前线程未持有锁，则返回0；如果当前线程持有锁，则返回持有的次数。
            return isHeldExclusively() ? getState() : 0;
        }

        final boolean isLocked() {
            // 返回锁是否已经被占用
            return getState() != 0;
        }

        final ConditionObject newCondition() {
            return new ConditionObject();
        }
    }

    static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;

        final void lock() {
            // 尝试占用锁
            if (compareAndSetState(0, 1))
                // 占用成功后，更新锁所属线程为当前线程
                setExclusiveOwnerThread(Thread.currentThread());
            else
                // 占用失败后，通过正常程序获取锁
                acquire(1);
        }

        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }

    static final class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;

        final void lock() {
            // 正常程序获取锁
            acquire(1);
        }

        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            // 判断锁是否未被持有
            if (c == 0) {
                // 如果队列为空或队头为当前线程时，就尝试占用锁
                if (!hasQueuedPredecessors() && compareAndSetState(0, acquires)) {
                    // 占用成功后，更新锁所属线程为当前线程
                    setExclusiveOwnerThread(current);
                    // 返回占用成功
                    return true;
                }
            }
            // 如果锁已被占用，判断当前线程是否持有锁
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                // 不允许锁被释放，否则视为系统错误
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                // 更新锁的持有次数
                setState(nextc);
                // 返回占用成功
                return true;
            }
            // 返回占用失败
            return false;
        }
    }

    public void lock() {
        // 获取锁
        sync.lock();
    }

    public void lockInterruptibly() throws InterruptedException {
        // 获取锁，可被中断
        sync.acquireInterruptibly(1);
    }

    public boolean tryLock() {
        // 强制使用非公平方式获取锁
        return sync.nonfairTryAcquire(1);
    }

    public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException {
        // 尝试在指定时间内获取锁，可被中断
        return sync.tryAcquireNanos(1, unit.toNanos(timeout));
    }

    public void unlock() {
        // 释放锁
        sync.release(1);
    }

    public int getHoldCount() {
        // 如果当前线程未持有锁，则返回0；如果当前线程持有锁，则返回持有的次数。
        return sync.getHoldCount();
    }

    public boolean isHeldByCurrentThread() {
        // 返回当前线程是否持有锁
        return sync.isHeldExclusively();
    }

    public boolean isLocked() {
        // 返回锁是否已经被占用
        return sync.isLocked();
    }

    public final boolean isFair() {
        // 返回是否公平锁
        return sync instanceof FairSync;
    }

    protected Thread getOwner() {
        // 返回锁的所属线程
        return sync.getOwner();
    }

    public final boolean hasQueuedThreads() {
        // 返回队列中是否还有线程，即是否队列不为空
        return sync.hasQueuedThreads();
    }

    public final boolean hasQueuedThread(Thread thread) {
        // 返回目标线程是否在队列中
        return sync.isQueued(thread);
    }

    public final int getQueueLength() {
        // 返回队列长度
        return sync.getQueueLength();
    }

    protected Collection<Thread> getQueuedThreads() {
        // 返回队列中的所有线程
        return sync.getQueuedThreads();
    }

    public Condition newCondition() {
        return sync.newCondition();
    }

    public boolean hasWaiters(Condition condition) {
        if (condition == null)
            throw new NullPointerException();
        if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
            throw new IllegalArgumentException("not owner");
        return sync.hasWaiters((AbstractQueuedSynchronizer.ConditionObject)condition);
    }

    public int getWaitQueueLength(Condition condition) {
        if (condition == null)
            throw new NullPointerException();
        if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
            throw new IllegalArgumentException("not owner");
        return sync.getWaitQueueLength((AbstractQueuedSynchronizer.ConditionObject)condition);
    }

    protected Collection<Thread> getWaitingThreads(Condition condition) {
        if (condition == null)
            throw new NullPointerException();
        if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
            throw new IllegalArgumentException("not owner");
        return sync.getWaitingThreads((AbstractQueuedSynchronizer.ConditionObject)condition);
    }

    public String toString() {
        Thread o = sync.getOwner();
        return super.toString() + ((o == null) ? "[Unlocked]" : "[Locked by thread " + o.getName() + "]");
    }
}

ReentrantReadWriteLock的源码分析：

/**
 * @since 1.5
 * @author Doug Lea
 */
public class ReentrantReadWriteLock implements ReadWriteLock, java.io.Serializable {
    private static final long serialVersionUID = -6992448646407690164L;
    private final ReentrantReadWriteLock.ReadLock readerLock;
    private final ReentrantReadWriteLock.WriteLock writerLock;
    final Sync sync;

    public ReentrantReadWriteLock() {
        this(false);
    }

    public ReentrantReadWriteLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
        readerLock = new ReadLock(this);
        writerLock = new WriteLock(this);
    }

    public ReentrantReadWriteLock.WriteLock writeLock() {
        return writerLock;
    }

    public ReentrantReadWriteLock.ReadLock readLock() {
        return readerLock;
    }

    abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 6317671515068378041L;

        static final int SHARED_SHIFT = 16;
        static final int SHARED_UNIT = (1 << SHARED_SHIFT);
        static final int MAX_COUNT = (1 << SHARED_SHIFT) - 1;
        static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;

        static int sharedCount(int c) {
            // 使用高16位存储共享锁的共享次数
            return c >>> SHARED_SHIFT;
        }

        static int exclusiveCount(int c) {
            // 使用低16位存储独占锁被持有次数
            return c & EXCLUSIVE_MASK;
        }

        static final class HoldCounter {
            int count = 0;
            final long tid = Thread.currentThread().getId();
        }

        static final class ThreadLocalHoldCounter extends ThreadLocal<HoldCounter> {
            public HoldCounter initialValue() {
                return new HoldCounter();
            }
        }

        private transient ThreadLocalHoldCounter readHolds;

        private transient HoldCounter cachedHoldCounter;

        private transient Thread firstReader = null;
        private transient int firstReaderHoldCount;

        Sync() {
            readHolds = new ThreadLocalHoldCounter();
            setState(getState()); // ensures visibility of readHolds
        }

        abstract boolean readerShouldBlock();

        abstract boolean writerShouldBlock();

        protected final boolean tryAcquire(int acquires) {
            Thread current = Thread.currentThread();
            int c = getState();
            int w = exclusiveCount(c);
            // 是否存在锁
            if (c != 0) {
                // 如果不存在独占锁，或当前线程并不是独占锁的所属线程，则返回获取失败
                if (w == 0 || current != getExclusiveOwnerThread())
                    return false;
                // 如果累加后的持有次数，达到最大值时，则系统错误
                if (w + exclusiveCount(acquires) > MAX_COUNT)
                    throw new Error("Maximum lock count exceeded");
                // 更新独占锁被当前钱程持有的次数
                setState(c + acquires);
                // 返回获取成功
                return true;
            }
            // 如果是公平策略，就需要当前线程是队头，非公平策略不需要。然后尝试占用锁
            if (writerShouldBlock() || !compareAndSetState(c, c + acquires))
                // 返回占用失败
                return false;
            // 占用成功后，更新独占锁的所属线程为当前线程
            setExclusiveOwnerThread(current);
            // 返回占用成功
            return true;
        }

        protected final boolean tryRelease(int releases) {
            // 不允许当前线程释放其它线程持有的独占锁，否则抛出异常
            if (!isHeldExclusively())
                throw new IllegalMonitorStateException();
            int nextc = getState() - releases;
            boolean free = exclusiveCount(nextc) == 0;
            // 如果独占锁的持有次数达到释放值，就清空独占锁的所属线程
            if (free)
                setExclusiveOwnerThread(null);
            // 更新独占锁被当前钱程持有的次数
            setState(nextc);
            // 返回独占锁是否已经被释放
            return free;
        }

        protected final int tryAcquireShared(int unused) {
            Thread current = Thread.currentThread();
            int c = getState();
            // 如果存在独占锁，并且该独占锁并不属于当前线程，就返回获取失败。
            if (exclusiveCount(c) != 0 && getExclusiveOwnerThread() != current)
                return -1;
            int r = sharedCount(c);
            // 如果是公平策略，就需要当前线程是队头，如果是非公平策略，就需要队头是以共享方式取锁。
            // 然后还需要共享次数未达到最大值
            // 如果前面条件满足后，就尝试占用锁（注：c + SHARED_UNIT表示增加1）
            if (!readerShouldBlock() && r < MAX_COUNT && compareAndSetState(c, c + SHARED_UNIT)) {
                // 如果首次占用共享锁，就记录首个占用共享锁的线程和占用次数
                if (r == 0) {
                    firstReader = current;
                    firstReaderHoldCount = 1;
                }
                // 如果不是首次占用，但当前线程就是那个首次占用共享锁的线程时，就增加记录次数
                else if (firstReader == current) {
                    firstReaderHoldCount++;
                }
                else {
                    // 从缓存或本地变量中获取计数器
                    HoldCounter rh = cachedHoldCounter;
                    if (rh == null || rh.tid != current.getId())
                        cachedHoldCounter = rh = readHolds.get();
                    else if (rh.count == 0)
                        readHolds.set(rh);
                    // 更新当前线程所占用共享锁的次数
                    rh.count++;
                }
                // 返回占用成功
                return 1;
            }
            return fullTryAcquireShared(current);
        }

        final int fullTryAcquireShared(Thread current) {
            HoldCounter rh = null;
            for (;;) {
                int c = getState();
                // 判断是否存在独占锁
                if (exclusiveCount(c) != 0) {
                    // 如果该独占锁并不属于当前线程，就返回获取失败。
                    if (getExclusiveOwnerThread() != current)
                        return -1;
                } else {
                    // 现在不存在独占锁，如果在公平策略下，当前线程不是队头，如果在非公平策略下，队头是以独占方式取锁
                    // 也不是首个占用共享锁的线程，也未有占用共享锁的记录在
                    if (readerShouldBlock() && firstReader != current) {
                        // 从缓存或本地变量中获取计数器
                        if (rh == null) {
                            rh = cachedHoldCounter;
                            if (rh == null || rh.tid != current.getId()) {
                                rh = readHolds.get();
                                if (rh.count == 0)
                                    readHolds.remove();
                            }
                        }
                        // 如果记录为0，就返回占用失败
                        if (rh.count == 0)
                            return -1;
                    }
                }

                // 现在：
                // 存在独占锁，并且当前线程是独占锁的所属线程
                // 不存在独占锁，当前线程有占用共享锁的记录在
                // 不存在独占锁，非公平策略，需要队头是以共享取锁才能插队占用共享锁
                // 不存在独占锁，公平策略，需要当前线程位于队头才能占用共享锁（即不能插队）

                // 不允许共享次数达到最大值，否则系统错误
                if (sharedCount(c) == MAX_COUNT)
                    throw new Error("Maximum lock count exceeded");
                // 尝试占用共享锁（注：c + SHARED_UNIT表示增加1）
                if (compareAndSetState(c, c + SHARED_UNIT)) {
                    // 如果首次占用共享锁，就记录首个占用共享锁的线程和占用次数
                    if (sharedCount(c) == 0) {
                        firstReader = current;
                        firstReaderHoldCount = 1;
                    }
                    // 如果不是首次占用，但当前线程就是那个首次占用共享锁的线程时，就增加记录次数
                    else if (firstReader == current) {
                        firstReaderHoldCount++;
                    } else {
                        // 从缓存或本地变量中获取计数器
                        if (rh == null)
                            rh = cachedHoldCounter;
                        if (rh == null || rh.tid != current.getId())
                            rh = readHolds.get();
                        else if (rh.count == 0)
                            readHolds.set(rh);
                        // 更新当前线程所占用共享锁的次数
                        rh.count++;
                        // 缓存记录
                        cachedHoldCounter = rh; // cache for release
                    }
                    // 返回占用成功
                    return 1;
                }
            }
        }

        protected final boolean tryReleaseShared(int unused) {
            Thread current = Thread.currentThread();
            // 判断当前线程是否为第一个占用共享锁的线程
            if (firstReader == current) {
                // 递减占用共享锁的记录
                if (firstReaderHoldCount == 1)
                    firstReader = null;
                else
                    firstReaderHoldCount--;
            } else {
                // 从缓存或本地变量中获取计数器
                HoldCounter rh = cachedHoldCounter;
                if (rh == null || rh.tid != current.getId())
                    rh = readHolds.get();
                // 如果当前线程未有占用共享的记录，则异常
                int count = rh.count;
                if (count <= 1) {
                    readHolds.remove();
                    if (count <= 0)
                        throw unmatchedUnlockException();
                }
                // 递减占用共享锁的记录
                --rh.count;
            }
            for (;;) {
                int c = getState();
                int nextc = c - SHARED_UNIT;
                // 尝试递减共享锁的占用次数，如果成功，则返回共享锁的全部占用都释放。
                if (compareAndSetState(c, nextc))
                    return nextc == 0;
            }
        }

        private IllegalMonitorStateException unmatchedUnlockException() {
            return new IllegalMonitorStateException("attempt to unlock read lock, not locked by current thread");
        }

        final boolean tryWriteLock() {
            Thread current = Thread.currentThread();
            int c = getState();
            // 是否存在锁
            if (c != 0) {
                int w = exclusiveCount(c);
                // 如果不存在独占锁，或当前线程不是独占锁的所属线程，则返回占用失败
                if (w == 0 || current != getExclusiveOwnerThread())
                    return false;
                // 如果当前线程持有独占锁的次数达到最大值，则系统错误
                if (w == MAX_COUNT)
                    throw new Error("Maximum lock count exceeded");
            }
            // 尝试占用独占锁
            if (!compareAndSetState(c, c + 1))
                // 近回占用失败
                return false;
            // 占用成功后，更新独占锁的所属线程为当前线程
            setExclusiveOwnerThread(current);
            return true;
        }

        final boolean tryReadLock() {
            Thread current = Thread.currentThread();
            for (;;) {
                int c = getState();
                // 如果存在独占锁，并且当前线程不是独占锁的所属线程，就返回占用失败
                if (exclusiveCount(c) != 0 && getExclusiveOwnerThread() != current)
                    return false;
                int r = sharedCount(c);
                // 如果共享锁的占用次数达到最值，则系统错误
                if (r == MAX_COUNT)
                    throw new Error("Maximum lock count exceeded");
                // 尝试占用共享锁
                if (compareAndSetState(c, c + SHARED_UNIT)) {
                    // ...
                    if (r == 0) {
                        firstReader = current;
                        firstReaderHoldCount = 1;
                    } else if (firstReader == current) {
                        firstReaderHoldCount++;
                    } else {
                        HoldCounter rh = cachedHoldCounter;
                        if (rh == null || rh.tid != current.getId())
                            cachedHoldCounter = rh = readHolds.get();
                        else if (rh.count == 0)
                            readHolds.set(rh);
                        rh.count++;
                    }
                    // 返回占用成功
                    return true;
                }
            }
        }

        protected final boolean isHeldExclusively() {
            // 返回当前线程是否持有独占锁
            return getExclusiveOwnerThread() == Thread.currentThread();
        }

        final Thread getOwner() {
            // 返回独占锁的所属线程
            return ((exclusiveCount(getState()) == 0) ? null : getExclusiveOwnerThread());
        }

        final int getReadLockCount() {
            // 返回共享锁的占用次数
            return sharedCount(getState());
        }

        final boolean isWriteLocked() {
            // 返回独占锁的占用次数
            return exclusiveCount(getState()) != 0;
        }

        final int getWriteHoldCount() {
            // 如果当前线程未持有独占锁，则返回0；如果当前线程持有独占锁，则返回持有的次数。
            return isHeldExclusively() ? exclusiveCount(getState()) : 0;
        }

        final int getReadHoldCount() {
            // 返回当前线程占用共享锁的次数

            // 如果独占锁未被占用，则返回0
            if (getReadLockCount() == 0)
                return 0;

            // 从第一个占用共享锁记录中（缓存）获取占用次数，并返回
            Thread current = Thread.currentThread();
            if (firstReader == current)
                return firstReaderHoldCount;

            // 从缓存中获取占用次数，并返回
            HoldCounter rh = cachedHoldCounter;
            if (rh != null && rh.tid == current.getId())
                return rh.count;

            // 从记录中获取占用次数，并返回
            int count = readHolds.get().count;
            if (count == 0)
                readHolds.remove();
            return count;
        }

        final int getCount() {
            // 返回锁的数量
            return getState();
        }

        final ConditionObject newCondition() {
            return new ConditionObject();
        }
    }

    static final class NonfairSync extends Sync {
        private static final long serialVersionUID = -8159625535654395037L;

        final boolean writerShouldBlock() {
            return false;
        }

        final boolean readerShouldBlock() {
            // 返回队头是否以独占方式获取锁
            // return apparentlyFirstQueuedIsExclusive();
            return false;
        }
    }

    static final class FairSync extends Sync {
        private static final long serialVersionUID = -2274990926593161451L;

        final boolean writerShouldBlock() {
            // 如果队列为空或队头为当前线程时，就返回false，否则返回true
            return hasQueuedPredecessors();
        }

        final boolean readerShouldBlock() {
            // 如果队列为空或队头为当前线程时，就返回false，否则返回true
            return hasQueuedPredecessors();
        }
    }

    public static class ReadLock implements Lock, java.io.Serializable {
        private static final long serialVersionUID = -5992448646407690164L;
        private final Sync sync;

        protected ReadLock(ReentrantReadWriteLock lock) {
            sync = lock.sync;
        }

        public void lock() {
            sync.acquireShared(1);
        }

        public void lockInterruptibly() throws InterruptedException {
            sync.acquireSharedInterruptibly(1);
        }

        public boolean tryLock() {
            // 尝试占用共享锁，并返回是否成功
            return sync.tryReadLock();
        }

        public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException {
            return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
        }

        public void unlock() {
            sync.releaseShared(1);
        }

        public Condition newCondition() {
            // 共享锁不允许创建条件对象
            throw new UnsupportedOperationException();
        }

        public String toString() {
            int r = sync.getReadLockCount();
            return super.toString() + "[Read locks = " + r + "]";
        }
    }

    public static class WriteLock implements Lock, java.io.Serializable {
        private static final long serialVersionUID = -4992448646407690164L;
        private final Sync sync;

        protected WriteLock(ReentrantReadWriteLock lock) {
            sync = lock.sync;
        }

        public void lock() {
            sync.acquire(1);
        }

        public void lockInterruptibly() throws InterruptedException {
            sync.acquireInterruptibly(1);
        }

        public boolean tryLock() {
            // 尝试占用独占锁，并返回是否成功
            return sync.tryWriteLock();
        }

        public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException {
            return sync.tryAcquireNanos(1, unit.toNanos(timeout));
        }

        public void unlock() {
            sync.release(1);
        }

        public boolean isHeldByCurrentThread() {
            // 返回当前线程是否持有独占锁
            return sync.isHeldExclusively();
        }

        public int getHoldCount() {
            // 如果当前线程未持有独占锁，则返回0；如果当前线程持有独占锁，则返回持有的次数。
            return sync.getWriteHoldCount();
        }

        public Condition newCondition() {
            return sync.newCondition();
        }

        public String toString() {
            Thread o = sync.getOwner();
            return super.toString() + ((o == null) ? "[Unlocked]" : "[Locked by thread " + o.getName() + "]");
        }
    }

    public final boolean isFair() {
        // 返回是否公平锁
        return sync instanceof FairSync;
    }

    protected Thread getOwner() {
        // 返回独占锁的所属线程
        return sync.getOwner();
    }

    public int getReadLockCount() {
        // 返回共享锁的占用次数
        return sync.getReadLockCount();
    }

    public boolean isWriteLocked() {
        // 返回独占锁的占用次数
        return sync.isWriteLocked();
    }

    public boolean isWriteLockedByCurrentThread() {
        // 返回当前线程是否持有独占锁
        return sync.isHeldExclusively();
    }

    public int getWriteHoldCount() {
        // 如果当前线程未持有独占锁，则返回0；如果当前线程持有独占锁，则返回持有的次数。
        return sync.getWriteHoldCount();
    }

    public int getReadHoldCount() {
        // 返回当前线程占用共享锁的次数
        return sync.getReadHoldCount();
    }

    protected Collection<Thread> getQueuedWriterThreads() {
        // 返回队列中以独占模式获取锁的所有线程
        return sync.getExclusiveQueuedThreads();
    }

    protected Collection<Thread> getQueuedReaderThreads() {
        // 返回队列中以共享模式获取锁的所有线程
        return sync.getSharedQueuedThreads();
    }

    public final boolean hasQueuedThreads() {
        // 返回队列中是否还有线程，即是否队列不为空
        return sync.hasQueuedThreads();
    }

    public final boolean hasQueuedThread(Thread thread) {
        // 返回目标线程是否在队列中
        return sync.isQueued(thread);
    }

    public final int getQueueLength() {
        // 返回队列长度
        return sync.getQueueLength();
    }

    protected Collection<Thread> getQueuedThreads() {
        // 返回队列中的所有线程
        return sync.getQueuedThreads();
    }

    public boolean hasWaiters(Condition condition) {
        if (condition == null)
            throw new NullPointerException();
        if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
            throw new IllegalArgumentException("not owner");
        return sync
                .hasWaiters((AbstractQueuedSynchronizer.ConditionObject) condition);
    }

    public int getWaitQueueLength(Condition condition) {
        if (condition == null)
            throw new NullPointerException();
        if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
            throw new IllegalArgumentException("not owner");
        return sync
                .getWaitQueueLength((AbstractQueuedSynchronizer.ConditionObject) condition);
    }

    protected Collection<Thread> getWaitingThreads(Condition condition) {
        if (condition == null)
            throw new NullPointerException();
        if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
            throw new IllegalArgumentException("not owner");
        return sync
                .getWaitingThreads((AbstractQueuedSynchronizer.ConditionObject) condition);
    }

    public String toString() {
        int c = sync.getCount();
        int w = Sync.exclusiveCount(c);
        int r = Sync.sharedCount(c);

        return super.toString() + "[Write locks = " + w + ", Read locks = " + r + "]";
    }
}