【Java多线程】自定义同步组件

　　前面章节（【Java多线程】队列同步器AQS（十一））中，对同步器AbstractQueuedSynchronized进行了实现层面的分析，本章通过编写一个自定义同步组件来加深对同步器的理解

同步组件要求

　　设计一个同步工具：该工具在同一时刻，只允许至多两个线程同时访问，这里显然是共享式访问将被组赛，我们将这个同步工具命名为TwinsLock。

　　首先，确定访问模式。TwinsLock能够在同一个时刻支持多个线程的访问，这显然是共享式访问，因此，需要使用同步器提供的 acquireShared(int args) 方法等和Shared相关的方法，这要求TwinsLock必须重写 tryAcquireShared(int args) 方法和 tryReleaseShared int args)，这样才能保证同步器的共享式同步状态的获取与释放方法得以执行。

　　其次，定义资源数。TwinsLock子啊同一时刻允许至多两个线程同时访问，表面同步资源数为2，这样可以设置初始状态 status 为2，当一个线程进行获取，status减1，该线程释放，则 status加1，状态的合法范围为0、1 和 2，其中0表示当前已经有两个线程获取了同步资源，此时再有其他线程对同步状态进行获取，该线程只能被阻塞。在同步状态变更时，需要使用 compareAndSetState(int expect, int update) 方法作为原子性保障

　　最后，组合自定义同步器。前面的章节提到，自定义同步组件通过组合自定义同步器来完成功能，一般情况下自定义同步器会被定义为自定义同步组件的内部类。

TwinsLock代码

　　TwinsLock代码如下：

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

    private static final class Sync extends AbstractQueuedSynchronizer {
        // 构造方法
        Sync(int count) {
            if(count <= 0){
                throw new IllegalArgumentException("count must large than zero.");
            }
            setState(count);
        }

        // 共享式获取同步状态
        @Override
        protected int tryAcquireShared(int reduceCount) {
            for(;;){
                int current = getState();
                int newCount = current - reduceCount;
                if(newCount < 0 || compareAndSetState(current, newCount)){
                    return newCount;
                }
            }
        }

        // 共享式释放同步状态
        @Override
        protected boolean tryReleaseShared(int returnCount) {
            for(;;){
                int current = getState();
                int newCount = current + returnCount;
                if(compareAndSetState(current, newCount)){
                    return true;
                }
            }
        }

        // 返回一个Condition，每个condition都包含了一个condition队列
        Condition newCondition() {
            return new ConditionObject();
        }

    }

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

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

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

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

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return false;
    }

    // 返回一个Condition，每个condition都包含了一个condition队列
    @Override
    public Condition newCondition() {
        return sync.newCondition();
    }

}

　　在上述示例中，TwinsLock实现了Lock接口，提供了面向使用者的接口，使用者调用lock()方法获取锁，随后调用unlock()方法释放锁，而同一时刻只能有两个线程同时获取到锁。

　　TwinsLock同时包含了一个自定义同步器Sync，而该同步器面向线程访问和同步状态控制。以共享式获取同步状态为例：同步器会先计算出获取后的同步状态，然后通过CAS确保状态的正确设置，当 tryAcquireShared(int reduceCount) 方法返回值大于等于0时，当前线程才获取同步状态，对于上层的TwinsLock而言，则表示当前线程获得了锁。

自定义同步组件测试

　　在测试用例中，定义了工作者线程Worker，该线程在执行过程中获取锁，当获取锁之后使当前线程睡眠1秒（并不释放锁），随后打印当前线程名称，最后再次睡眠1秒并释放锁。

public class TwinsLockTest {

    @Test
    public void test() {
        final Lock lock = new TwinsLock();
        class Worker extends Thread {
            @Override
            public void run() {
                while (true) {
                    lock.lock();
                    try {
                        SleepUtils.second(1);
                        System.out.println(Thread.currentThread().getName());
                        SleepUtils.second(1);
                    } finally {
                        lock.unlock();
                    }
                }
            }
        }

        //启动10个线程
        for (int i = 0; i < 10; i++) {
            Worker w = new Worker();
            w.setDaemon(true);
            w.start();
        }

        //每隔1秒换行
        for (int i = 0; i < 100; i++) {
            SleepUtils.second(1);
            System.out.println();
        }
    }


    public static class SleepUtils{
        public static final void second(long sec) {
            try {
                TimeUnit.SECONDS.sleep(sec);
            } catch (Exception e) {
                // TODO: handle exception
            }
        }
    }
}

　　运行该测试用例，可以看到线程名称成对输出，也就是在同一时刻只有两个线程能够获取到锁，这表明TwinsLock可以按照预期正确工作。

　　

参考文章：

　　1、《Java并发编程的艺术》

　　2、https://blog.csdn.net/cold___play/article/details/104055201