利用队列同步器构建ReentrantLock

ReentrantLock即重入锁，支持一个线程对资源重复加锁。除此之外，该锁还支持获取锁时公平性和非公平性选择。
前面我的博客中实现的Mutex不支持重入。Synchronized关键字隐式支持重进入。
对于ReentrantLock，已经获取到锁的线程再次调用lock方法获取锁不被阻塞。
公平地获取锁就是等待时间最长地线程优先获取锁，锁的获取是顺序的。
下面是公平获取锁和非公平获取锁的代码

public static class Sync extends AbstractQueuedSynchronizer
    {

        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 exceed");
                }
                setState(nextc);
                return true;
            }
            return false;
        }
        protected final boolean nofairTryAcquire(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)
                {
                    throw new Error("Maximum lock count exceed");
                }
                setState(nextc);
                return true;
            }
            return false;
        }
        protected final boolean tryRelease(int releases)
        {
            for(;;)
            {
                int current=getState();
                int c=current-releases;
                if(Thread.currentThread()!=getExclusiveOwnerThread())
                {
                    throw new IllegalMonitorStateException();
                }
                boolean free=false;
                if(c==0)
                {//当状态值减为0才表示真正释放了锁，这时才能返回true
                    free=true;
                    setExclusiveOwnerThread(null);
                }
                if(compareAndSetState(current,c))
                    return free;
            }
        }

(1)线程再次获取锁。锁需要识别获取到锁的线程是否为当前占据锁的线程，如果是就再次成功获取，否则就阻塞。锁的获取需要计数自增
(2)锁的最终释放。线程重复 n 次获取了锁，随后在第 n 次释放该锁后，其他线程才能获取到该锁。锁的释放需要计数自减，当计数为0表示锁已经成功释放，并返回true，否则返回false