自己基于AQS实现一个同步器

迈不过友情╰ 2023-01-17 09:16 66阅读 0赞

目标:实现一个只能同时最多有两个线程同时访问的的同步器。

public class MyLock implements Lock {
    
        private final Sync sync = new Sync(2);
    
        private static final class Sync extends AbstractQueuedSynchronizer{
            Sync(int count){
                setState(count);
            }
    
            @Override
            public int tryAcquireShared(int reduceCount){
                for(;;){
                    int current = getState();
                    int newCount = current - reduceCount;
                    if(newCount < 0 || compareAndSetState(current, newCount)){
                        return newCount;
                    }
                }
            }
    
            @Override
            public 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 lockInterruptibly() throws InterruptedException {
            sync.acquireSharedInterruptibly(1);
        }
    
        @Override
        public boolean tryLock() {
            return sync.tryAcquireShared(1) >= 0;
        }
    
        @Override
        public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
            return sync.tryAcquireSharedNanos(1, unit.toNanos(time));
        }
    
        @Override
        public void unlock() {
            sync.releaseShared(1);
        }
    
        @Override
        public Condition newCondition() {
            return null;
        }
    
        public static void main(String[] args) throws InterruptedException {
            final Lock lock = new MyLock();
            int times = 10;
            CountDownLatch countDownLatch = new CountDownLatch(times);
            for (int i = 0; i < times; i++) {
                new Thread(() -> {
                    lock.lock();
                    try {
                        Thread.sleep(1000L);
                        System.out.println(Thread.currentThread());
                        Thread.sleep(1000L);
                    } catch (Exception ex) {
                    } finally {
                        lock.unlock();
                        countDownLatch.countDown();
                    }
                }).start();
            }
            countDownLatch.await();
    
        }
    }