利用队列同步器AbstractQueuedSynchronizer构建TwinsLock

TwinsLock在同一时刻最多支持两个线程访问，超过两个线程的访问将被阻塞，这是共享式的访问

package twinslock;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

public class TwinsLock implements Lock 
{
    private final Sync sync=new Sync(2); 

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

    @Override
    public boolean tryLock() {
        sync.tryAcquireShared(1);
        return true;
    }

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

    @Override
    public Condition newCondition() {
        return sync.newCondition();
    }
    private static final class Sync extends AbstractQueuedSynchronizer
    {
        Sync(int count)
        {
            if(count<=0)
            {
                throw new IllegalArgumentException("count must lsrge than zero");
            }
            setState(count);//设置同步资源数为count
            //当一个线程成功获取同步状态时，状态值减1，释放同步状态时状态值加1，状态值为0表示已经有两个两个线程获取同步资源，此时再有其他线程对同步状态进行获取将会被阻塞
        }
        public int tryAcquireShared(int reduceCount)
        {
            for(;;)
            {
                int current=getState();
                int newCount=current-reduceCount;
                if(newCount<0||compareAndSetState(current,newCount))
                {//此处的CAS操作很重要，如果此线程计算出newCount之后其他线程改变了队列同步器的状态值，原来的newCount已经不是需要正确更新的状态值了
                    return newCount;
                }
            }
        }
        public boolean tryReleaseShared(int returnCount)
        {
            for(;;)
            {
                int current=getState();
                int newCount=current+returnCount;
                if(compareAndSetState(current,newCount))
                {
                    return true;
                }
            }
        }
        public Condition newCondition()
        {
            return new ConditionObject();
        }
    }
    public void lock()
    {
        sync.acquireShared(1);
    }
    public void unlock()
    {
        sync.releaseShared(1);
    }
}