Java并发--使用AQS自定义同步组件TwinsLock

小咪咪 2021-08-13 20:50 329阅读 0赞

### TwinsLock ###

设计一个同步工具：该工具在同一时刻，只允许至多两个线程同时访问，超过两个线程的  
访问将被阻塞，我们将这个同步工具命名为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表示当前已经有两个线程获取了同步资源，此时再有其他线程对同步状态进行获取，该线程只能被阻塞。在同步状态变更时，需要使用compareAndSet(int expect,int update)方法做原子性保障。

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

package pers.zhang.part5;
    
    import com.sun.corba.se.impl.orbutil.concurrent.Sync;
    
    import java.util.concurrent.locks.AbstractQueuedSynchronizer;
    import java.util.concurrent.locks.Lock;
    
    /** * @author zhang * @date 2020/1/20 - 18:35 * */
    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;
                    }
                }
            }
            
        }
        
        @Override
        public void lock(){ 
            sync.acquireShared(1);
        }
        
        @Override
        public void unlock(){ 
            sync.releaseShared(1);
        }
        
        //其他接口方法略
    }

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

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

测试：

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

package pers.zhang.part5;
    
    import org.junit.Test;
    import pers.zhang.part4.SleepUtils;
    
    import java.util.concurrent.locks.Lock;
    
    /** * @author zhang * @date 2020/1/20 - 18:42 */
    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 < 10; i++){ 
                SleepUtils.second(1);
                System.out.println();
            }
        }
    }

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