多线程基础学习十一：AbstractQueuedSynchronizer了解

小灰灰 2022-06-05 07:28 224阅读 0赞

上一片学习了Lock顶级接口，现在学习一下队列同步器AbstractQueuedSynchronizer，也就是网上常看到AQS。

### AbstractQueuedSynchronizer ###

目前我看到的Lock的实现最终都是通过AQS同步器来实现同步，所以了解这个类对了解Lock的实现有很大的帮助。

这个类提供了很多方法：  
![这里写图片描述][SouthEast]

根据源码注释，非常容易理解到，这个类提供了和lock类似功能的方法。  
比如这一组方法（独占锁）：  
\- **acquire(int)** 获取锁  
\- **acquireInterruptibly(int)** 获取锁并响应中断  
\- **tryAcquireNanos(int, long)** 持续一段时间获取锁，获取到返回true，获取不到或者超时返回false  
\- **release(int)**  释放锁  
还有一组（共享锁）：  
\- **acquireShared(int)** 获取锁  
\- **acquireSharedInterruptibly(int)** 获取锁并响应中断  
\- **tryAcquireSharedNanos(int, long)** 持续一段时间获取锁，获取到返回true，获取不到或者超时返回false  
\- **releaseShared(int)**  释放锁

*ps：独占锁和共享锁，后面再详细了解*

唯一和Lock接口有区别的是获取锁和释放锁的调用，多了一个int参数，这个参数的意义是什么？

源码注释：

arg the acquire argument.  This value is conveyed to
         *        {@link #tryAcquire} but is otherwise uninterpreted and
         *        can represent anything you like

注释上说这个参数是给tryAcquire方法使用的，可以代表你喜欢的任何东西。

**可以还是无法理解这个参数的意义，希望以后了解的多了，能够理解这个参数，当然如果有大神看到我这篇了解AQS的博客，能在评论里指点一下。**

### 基本使用 ###

这个类是一个抽象类，抽象类是没法直接使用的，所以注释里给了最常用的使用方式。

常用使用方式：

public class Mutex implements Lock{ 
    
        private static class Sync extends AbstractQueuedLongSynchronizer { 
    
            @Override
            protected boolean tryAcquire (long arg) {
    
                if (compareAndSetState(0, 1)) {
                    setExclusiveOwnerThread(Thread.currentThread());
                    return true;
                }
    
                return false;
            }
    
            @Override
            protected boolean tryRelease (long arg) {
    
                if (getState() == 0) {
                    throw new IllegalMonitorStateException();
                } else {
                    setExclusiveOwnerThread(null);
                }
    
                setState(0);
                return true;
            }
    
            @Override
            protected boolean isHeldExclusively () {
                return getState() == 1;
            }
    
            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 (long time, TimeUnit unit) throws InterruptedException {
            return sync.tryAcquireNanos(1, unit.toNanos(time));
        }
    
        @Override
        public boolean tryLock () {
            return sync.tryAcquire(1);
        }
    
        @Override
        public void unlock () {
            sync.tryRelease(1);
        }
    
        @Override
        public Condition newCondition () {
            return sync.newCondition();
        }
    }

在常用的使用方式中，类实现了Lock接口，类中有一个内部类继承了AQS，把操作锁的方法都委托给了内部类来实现。

比如最常用的ReentranLock就是这种实现方式。

网上有很多关于AQS的实现原理的，都是很好的文章，以后有需要再看。

[SouthEast]: /images/20220605/13fafb855cb24269b0cd13586aa07077.png