AQS抽象队列同步器的实现以及java中的并发工具类的实现

下面为自己实现的一个

aqs

public class WangAqs {

    //如何判断一个资源的拥有者
    public volatile AtomicReference<Thread> owner=new AtomicReference<>();
    //保存正在等待的线程
    public volatile LinkedBlocking`在这里插入代码片`Queue<Thread> waiters=new LinkedBlockingQueue();
    //记录资源状态
    public volatile AtomicInteger state=new AtomicInteger(0);

    //共享资源的逻辑,返回资源的占用情况
    public int tryAcquireShared(){
        throw new UnsupportedOperationException();
    }
    public void acquireShared(){
        boolean addQ=true;
        while (tryAcquireShared()<0){
            if (addQ) {
                //没拿到锁，加入到等待队列
                waiters.offer(Thread.currentThread());
                addQ=false;
            }else {
                //阻塞当前线程
                LockSupport.park();
            }
        }
        waiters.remove(Thread.currentThread());
    }
    public void releaseShared(){
        if (tryReleaseShared()){
            if(owner.compareAndSet(Thread.currentThread(),null)){    //释放成功
                //通知等待者
                Iterator<Thread> iterator = waiters.iterator();
                while (iterator.hasNext()){
                    Thread next = iterator.next();
                    LockSupport.unpark(next);
                }
            }
        }
    }

    public  boolean tryReleaseShared() {
        throw  new UnsupportedOperationException();
    }

    //定义独占资源争用的逻辑，如果没拿到，就等待
    public void acquire(){
        boolean addQ=true;
        while (!tryAcquire()){
            if (addQ) {
                //没拿到锁，加入到等待队列
                waiters.offer(Thread.currentThread());
                addQ=false;
            }else {
                //阻塞当前线程
                LockSupport.park();
            }
        }
        waiters.remove(Thread.currentThread());
    }

    public boolean tryAcquire(){
        //模板设计方法
        //交给使用者去实现
        throw new UnsupportedOperationException();
    }

    public void release(){
        if (tryRelease()){
            if(owner.compareAndSet(Thread.currentThread(),null)){    //释放成功
                //通知等待者
                Iterator<Thread> iterator = waiters.iterator();
                while (iterator.hasNext()){
                    Thread next = iterator.next();
                    LockSupport.unpark(next);
                }
            }
        }
    }

    public boolean tryRelease() {
        throw  new UnsupportedOperationException();
    }

    public AtomicInteger getState() {
        return state;
    }

    public void setState(AtomicInteger state) {
        this.state = state;
    }
}

AQS的核心思想是，如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并将共享资源设置为锁定状态，如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制，这个机制AQS是用CLH队列锁实现的，即将暂时获取不到锁的线程加入到队列中。
CLH（Craig，Landin，and Hagersten）队列是一个虚拟的双向队列，虚拟的双向队列即不存在队列实例，仅存在节点之间的关联关系。
实现了AQS的锁有：自旋锁、互斥锁、读锁写锁、条件产量、信号量、栅栏都是AQS的衍生物
下面是自己实现的

倒计数器

public class WangCDL {
    WangAqs aqs=new WangAqs(){
        @Override
        public int tryAcquireShared() {
            //如果非等于0，代表当前还有线程没有准备好，则认为就需要等待
            return this.getState().get()==0?1:-1;
        }

        @Override
        public boolean tryReleaseShared() {
            //如果非等于0，代表当前还有线程没有准备好，则不会通知继续执行
            return this.getState().decrementAndGet()==0;
        }
    };

    public WangCDL(int count){
        aqs.setState(new AtomicInteger(count));
    }

    public void await(){
        aqs.acquireShared();
    }

    public void countDown(){
        aqs.releaseShared();
    }
}

信号量

public class WangSemaphore {
    WangAqs aqs = new WangAqs() {

        @Override
        public int tryAcquireShared() {
            for (; ; ) {
                int count = getState().get();
                int n = count - 1;
                if (count <= 0 || n < 0) {
                    return -1;
                }
                if (getState().compareAndSet(count, n)) {
                    return 1;
                }
            }
        }

        @Override
        public boolean tryReleaseShared() {
            return getState().incrementAndGet() >= 0;
        }
    };

    public WangSemaphore(int count) {    //设置资源的状态
        aqs.getState().set(count);
    }

    public void acquire() {
        //获取令牌
        aqs.acquireShared();
    }

    public void release() {
        //释放令牌
        aqs.releaseShared();
    }
}

根据ReentrantLock实现了一个独占锁

//自己实现（独享锁）
public class WangLock implements Lock {

   WangAqs aqs=new WangAqs(){

       @Override
       public boolean tryAcquire() {
           return owner.compareAndSet(null,Thread.currentThread());
       }

       @Override
       public boolean tryRelease(){
            return owner.compareAndSet(Thread.currentThread(),null);
       }
   };
    @Override
    public void lock() {
        aqs.acquire();
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {

    }


    @Override
    public boolean tryLock() {
       return aqs.tryAcquire();
    }

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


    @Override
    public void unlock() {
        aqs.release();
    }

    @Override
    public Condition newCondition() {
        return null;
    }

}