Java多线程与并发编程(6)_AQS锁同步器

待我称王封你为后i 2023-02-19 13:23 7阅读 0赞

## AQS ##

> AQS全称是 AbstractQueuedSynchronizer，也称“同步器”，是阻塞式锁和相关的同步器工具的框架
> 
> AQS有如下特点：
> 
>  *  用 state 属性来表示资源的状态，子类需要定义如何维护这个状态，控制如何获取锁和释放锁 0代表无线程持有锁、 1代表锁被线程占用。
>     
>      *  `getState` \- 获取 state 状态
>      *  `setState` \- 设置 state 状态
>      *  `compareAndSetState` \- 通过cas 机制设置 state 状态
>      *  **独占模式是只有一个线程能够访问资源，而共享模式可以允许多个线程访问资源**
>  *  提供了基于 FIFO 的等待队列，类似于 Monitor 的 EntryList
>  *  条件变量来实现等待、唤醒机制，**支持多个条件变量**，类似于 Monitor 的 WaitSet（ConditionObject）
> 
> 同步器AQS的子类主要对以下方法进行实现
> 
>  *  `tryAcquire()`：尝试获取锁
>  *  `tryRelease()`：尝试释放锁
>  *  `isHeldExclusively()`:判断是否线程独占
> 
> > 获取锁的姿势
> > 
> >     //如果获取锁失败
> >     if (!tryAcquire(arg)) {
> >           
> >     // 入队, 可以选择阻塞当前线程 park unpark
> >     }
> > 
> > 释放锁的姿势
> > 
> >     //如果释放锁成功
> >     if (tryRelease(arg)) {
> >           
> >     // 让阻塞线程恢复运行
> >     }

## 基于AQS自定义一把不可重入锁 ##

第一步：重写同步器

//集成AQS
    final class MySync extends AbstractQueuedSynchronizer {
        
    
        //重写tryAcquire
        @Override
        protected boolean tryAcquire(int acquires) {
        
            if (acquires == 1){
        
                //0代表无线程持有锁，1代表有线程持有锁，尝试变更锁状态
                if (compareAndSetState(0,1)){
        
                    //设置锁的持有者
                    setExclusiveOwnerThread(Thread.currentThread());
                    return true ;
                }
            }
            return false ;
        }
    
        //重写释放锁
        @Override
        protected boolean tryRelease(int acquires) {
        
            
            if (acquires == 1){
        
                if (getState() == 0) throw new IllegalMonitorStateException();
                setExclusiveOwnerThread(null);
                setState(0);
                return true ;
            }
            return false ;
        }
    
    
        //锁是否被占用
        @Override
        protected boolean isHeldExclusively() {
        
            return getState() == 1  ;
        }
    
        //自己添加一个返回条件变量的方法
        protected Condition newCondition(){
        
            return new ConditionObject();
        }
    }

第二步：编写一个锁类，需要继承JUC的Lock接口，该接口定义了一个锁的基本方法，利用我们上面的AQS，可以很轻松的实现Lock接口

class MyLock implements Lock{
        
        //组合自定义同步器
        static MySync sync = new MySync() ;
    
        @Override
        //将锁状态置为1
        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() {
        
            //返回AQS的条件变量质上
          	//每个条件变量其实就对应着一个等待队列
            return sync.newCondition();
        }
        
    }

测试：

//test
        public static void main(String[] args) {
        
            MyLock lock = new MyLock() ;
            new Thread(()->{
        
                //上锁
                lock.lock();
                try {
        
                    System.out.println("t1 locking ..."+new Date());
                    Thread.sleep(1000);
                }finally {
        
                    //异常解锁
                    System.out.println("t1 unlocking ..."+new Date());
                    lock.unlock();
                }
            }).start();
    
            new Thread(()->{
        
                lock.lock();
                try {
        
                    System.out.println("t2 locking ..."+new Date());
                }finally {
        
                    System.out.println("t2 unlocking ..."+new Date());
                    lock.unlock();
                }
            }).start();
        }

> 结果：
> 
> t1 locking …Sat Jun 20 19:30:15 CST 2020  
> t1 unlocking …Sat Jun 20 19:30:16 CST 2020  
> t2 locking …Sat Jun 20 19:30:16 CST 2020  
> t2 unlocking …Sat Jun 20 19:30:16 CST 2020

t1先上锁，等待一秒解锁，t2得以执行，证明这个自定义锁写的没问题

## CLH ##

**阻塞队列设计**：

*  实现了 FIFO 先入先出队列
 *  CLH(Craig,Landin,and Hagersten)队列，AQS 是将每条请求共享资源的**线程封装**成一个 CLH 的一个结点（Node）来实现线程的排队阻塞。
 *  基本构成就是Head、Tail、每个Node的pre、next
 *  节点的操作是无锁自旋的，效率高  
    ![format_png][]

> **主要用到** **AQS** **的并发工具类**
> 
>  *  CountDownLatch
>  *  ReentrantReadWriteLock
>  *  ReentrantLock
>  *  Semaphore

[format_png]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9naXRlZS5jb20vanVuc2lyMS9NeVBpY0Nsb3VkU3RvcmUvcmF3L21hc3Rlci9pbWcvMjAyMDA2MjAyMDAxMDIucG5n?x-oss-process=image/format,png