07并发编程_AQS

什么是AQS?

        AQS，即AbstractQueuedSynchronizer, 队列同步器，它是Java并发用来构建锁和其他同步组件的基础框架。

AQS使用方式和其中的设计模式

继承、模板方法设计模式

了解其用法

模板方法

    独占式获取锁

          acquire

          acquireInterruptily

          tryAcquireNanos

共享式获取锁

         acquireShared

         acquireSharedInterruptily

         tryAcquireShareNanos

独占式释放锁

         release

共享式释放锁

         releaseShared

需要子类覆盖的流程方法

     独占式获取锁

          tryAcquire

     独占式释放

         tryRelease

共享式获取

        tryAcquireShared

共享式释放

       tryReleaseShared

这个同步器是否处于独占模式

       isHeldExclusively

同步状态state

        getState：获取当前的同步状态

       setState: 设置当前的同步状态

       compareAndSetState,使用CAS设置状态，保证状态设置的原子性

实现一个类似于ReentrantLock的锁

public class SelfLock implements Lock {

    //state 表示获取到锁 state = 1表示获取到锁
    //state = 0 表示没有获取锁
    private static class Sync extends AbstractQueuedSynchronizer{

        //是否处于占用
        protected boolean idHeldExclusively(){
            return getState() == 1;
        }

        protected boolean tryAcquire(int arg){
            if(compareAndSetState(0,1)){
                //表示当前线程拿到了锁
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }

        protected boolean tryRelease(int arg){
            if(getState() == 0){
                throw new UnsupportedOperationException();
            }
            setExclusiveOwnerThread(null);
            setState(0);
            return true;
        }

        Condition newCondition(){
            return new ConditionObject();
        }
    }

    private final Sync sync = new Sync();

    @Override
    public void lock() {
        //因为是独占锁
        sync.acquire(1);
    }

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

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

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return sync.tryAcquireNanos(1,unit.toNanos(time));
    }

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

    @Override
    public Condition newCondition() {
        return sync.newCondition();
    }
}

public class TestSelfLock {

    public void test(){
        final Lock lock = new SelfLock();
        class Worker extends Thread{

            public void run(){
                while(true){
                    try {
                        lock.lock();
                        SleepTools.ms(1);
                        System.out.println(Thread.currentThread().getName());
                        SleepTools.ms(1);
                    } finally {
                        lock.unlock();
                    }
                    SleepTools.ms(2);
                }
            }
        }

        for (int i = 0; i < 10; i++) {
            Worker w = new Worker();
            w.setDaemon(true);
            w.start();
        }

        for (int i = 0; i < 10; i++) {
            SleepTools.ms(10);
            System.out.println();
        }
    }

    public static void main(String[] args) {
        TestSelfLock testSelfLock = new TestSelfLock();
        testSelfLock.test();
    }
}

 源码分析参考 https://www.cnblogs.com/fanBlog/p/9336126.html  这篇文章，很详细