设计一个同步工具：该工具在同一时刻，只允许至多两个线程同时访问，超过两个线程的
    访问将被阻塞，我们将这个同步工具命名为TwinsLock。

    要求同步工具支持两个线程同时获得锁，所以需要acquireShared这个共享的方法。

    看一下AQS中acquireShared的实现

    1.     public final void acquireShared(int arg) {
    2.         // 调用tryAcquireShared方法
    3.         if (tryAcquireShared(arg) < 0)
    4.             // 当返回结果小于0的时候，进行阻塞
    5.             doAcquireShared(arg);
    6.     }
    9.     // 没有实现，是留给子类实现的
    10.     protected int tryAcquireShared(int arg) {
    11.         throw new UnsupportedOperationException();
    12.     }

    因此需要一个类实现tryAcquireShared方法。

    同理，releaseShared也是需要实现tryReleaseShared方法。

    2.     public final boolean releaseShared(int arg) {
    3.         if (tryReleaseShared(arg)) {
    4.             doReleaseShared();
    5.             return true;
    6.         }
    7.         return false;
    8.     }
    11.     protected boolean tryReleaseShared(int arg) {
    12.         throw new UnsupportedOperationException();
    13.     }

    实现：

    2. public class TwinsLock implements Lock {
    4.     // 在Lock中需要一个同步器，有2个计数
    5.     Sync sync = new Sync(2);
    6.     // 同步器继承AQS
    7.     private static final class Sync extends AbstractQueuedSynchronizer{
    8.         Sync(int count) {
    9.             if (count <= 0) {
    10.                 throw new IllegalArgumentException();
    11.             }
    12.             setState(count);
    13.         }
    15.         @Override
    16.         protected int tryAcquireShared(int reduceCount) {
    17.             for (;;){
    18.                 int cur = getState();
    19.                 // 获取加锁后state的值
    20.                 int newCount = cur - reduceCount;
    21.                 // 如果小于0，说明无法加锁，自旋
    22.                 // 如果cas失败，说明加锁失败，自旋
    23.                 if (newCount < 0 || compareAndSetState(cur, newCount)){
    24.                     return newCount;
    25.                 }
    26.             }
    27.         }
    29.         @Override
    30.         protected boolean tryReleaseShared(int returnCount) {
    31.             for (;;) {
    32.                 int cur = getState();
    33.                 int newCount = cur + returnCount;
    34.                 if (compareAndSetState(cur, newCount)) {
    35.                     return true;
    36.                 }
    37.             }
    38.         }
    39.     }
    41.     @Override
    42.     public void lock() {
    43.         sync.acquireShared(1);
    44.     }
    46.     @Override
    47.     public void lockInterruptibly() throws InterruptedException {    }
    49.     @Override
    50.     public boolean tryLock() {    return false;        }
    52.     @Override
    53.     public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {    return false;    }
    55.     @Override
    56.     public void unlock() {
    57.         sync.releaseShared(1);
    58.     }
    60.     @Override
    61.     public Condition newCondition() {    return null;    }
    62. }

    当前以上代码实际上是有点小问题的，因为释放锁的时候没有进行判断是否该线程已经上锁。
    这部分的释放锁可以去看ReentrantReadWriteLock中的实现。