JUC-AQS原理

• AQS全名为AbstractQueuedSynchronizer ，它是阻塞式锁和相关同步工具的框架

public abstract class AbstractQueuedSynchronizer
extends AbstractOwnableSynchronizer
implements Serializable

• AQS特点

1. 用state属性来表示资源的状态（分为独占式和共享式），子类需要定义和维护这个状态，控制如何获取锁和维护锁。
   getState：获取状态 setState：设置状态 compareAndSetState：CAS的机制来设置状态
   独占式：允许一个线程访问资源 共享式：允许多个线程访问资源
2. 提供FIFO等待队列，类似于Monitor的EntryList
3. 条件变量来实现等待，唤醒机制，支持多个条件变量，类似于Monitor的WaitSet

利用AQS实现自定义不可重入锁

class Mylock implements Lock{
    private Mysync mysync=new Mysync();
    //独占锁-同步器类
    class Mysync extends AbstractQueuedSynchronizer{
        @Override//尝试获取锁(一次尝试，不成功则放弃)
        protected boolean tryAcquire(int arg) {
            if (compareAndSetState(0,1)){
                //设置了state，然后设置owner持有者为当前线程
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }

        @Override//尝试解锁
        protected boolean tryRelease(int arg) {
            setExclusiveOwnerThread(null);//这个方法不是Volatile所以放在setState之前这样在执行过setstate后它对别的线程也是可见的
            setState(0);
            return  true;
        }

        @Override//是否持有独占锁
        protected boolean isHeldExclusively() {
            return getState()==1;
        }
    }

    @Override//尝试获取锁，不成功会进去等待队列
    public void lock() {
        mysync.acquire(1);
    }

    @Override//加锁，可打断
    public void lockInterruptibly() throws InterruptedException {
        mysync.acquireInterruptibly(1);
    }

    @Override//我们自己写的方法，尝试获取锁（一次）
    public boolean tryLock() {
        return mysync.tryAcquire(1);
    }

    @Override//尝试加锁带超时
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return false;
    }

    @Override//解锁
    public void unlock() {
        mysync.release(0);
    }

    @Override//创建条件变量
    public Condition newCondition() {
        return newCondition();
    }
}

public class Demo2 {
    public static void main(String[] args) {
        String s="nihao";
        Mylock mylock=new Mylock();
        new Thread(()->{
            mylock.lock();
            try{
                System.out.println(s);
            }finally {

            }
        }).start();
        new Thread(()->{
            mylock.lock();
            try{
                System.out.println(s);
            }finally {

            }
        }).start();

    }
}