Java并发--队列同步器（AbstractQueuedSynchronizer）

心已赠人 2021-08-13 15:27 507阅读 0赞

### 队列同步器（AQS） ###

队列同步器AbstractQueuedSynchronizer（以下简称同步器），是用来构建锁或者其他同步组件的基础框架，**它使用了一个int成员变量表示同步状态，通过内置的FIFO队列来完成资源获取线程的排队工作。**

**同步器的主要使用方式是继承，子类通过继承同步器并实现它的抽象方法来管理同步状态，在抽象方法的实现过程中免不了要对同步状态进行更改，这时就需要使用同步器提供的3个方法（getState()、setState(int newState)和compareAndSetState(int expect,int update)）来进行操作，因为它们能够保证状态的改变是安全的。** 子类推荐被定义为**自定义同步组件的静态内部类**，同步器自身没有实现任何同步接口，它仅仅是定义了若干同步状态获取和释放的方法来供自定义同步组件使用，同步器既可以支持独占式地获取同步状态，也可以支持共享式地获取同步状态，这样就可以方便实现不同类型的同步组件（ReentrantLock、ReentrantReadWriteLock和CountDownLatch等）。

同步器是实现锁（也可以是任意同步组件）的关键，在锁的实现中聚合同步器，利用同步器实现锁的语义。可以这样理解二者之间的关系：锁是面向使用者的，它定义了使用者与锁交互的接口（比如可以允许两个线程并行访问），隐藏了实现细节；同步器面向的是锁的实现者，它简化了锁的实现方式，屏蔽了同步状态管理、线程的排队、等待与唤醒等底层操作。锁和同步器很好地隔离了使用者和实现者所需关注的领域。

### 队列同步器的接口与示例 ###

同步器的设计是基于模板方法模式的，也就是说，使用者需要继承同步器并重写指定的方法，随后将同步器组合在自定义同步组件的实现中，并调用同步器提供的模板方法，而这些模板方法将会调用使用者重写的方法。

重写同步器指定的方法时，需要使用同步器提供的如下3个方法来访问或修改同步状态。

*  **getState**()：获取当前同步状态。
 *  **setState**(int newState)：设置当前同步状态。
 *  **compareAndSetState**(int expect,int update)：使用CAS设置当前状态，该方法能够保证状态  
    设置的原子性。

同步器可重写的方法如下：

![在这里插入图片描述][20200120173803596.png]  
![在这里插入图片描述][20200120173858992.png]  
实现自定义同步组件时，将会调用同步器提供的模板方法，这些（部分）模板方法与描述：  
同步器的模板方法：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbGRfX19wbGF5_size_16_color_FFFFFF_t_70]  
同步器提供的模板方法基本上分为3类：**独占式获取与释放同步状态**、**共享式获取与释放同步状态**和**查询同步队列中的等待线程情况**。自定义同步组件将使用同步器提供的模板方法来实现自己的同步语义。

示例：自定义独占锁

顾名思义，独占锁就是在同一时刻只能有一个线程获取到锁，而其他获取锁的线程只能  
处于同步队列中等待，只有获取锁的线程释放了锁，后继的线程才能够获取锁

package pers.zhang.part5;
    
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.locks.AbstractQueuedSynchronizer;
    import java.util.concurrent.locks.Condition;
    import java.util.concurrent.locks.Lock;
    
    /** * @author zhang * @date 2020/1/20 - 17:42 * * 使用AQS自定义独占锁 */
    public class Mutex implements Lock { 
        //静态内部类，自定义同步器
        private static class Sync extends AbstractQueuedSynchronizer{ 
            //是否处于占用状态
            @Override
            protected boolean isHeldExclusively() { 
                return getState() == 1;
            }
    
            //当状态为0的时候获取锁
            @Override
            protected boolean tryAcquire(int arg) { 
                if(compareAndSetState(0, 1)){ 
                    setExclusiveOwnerThread(Thread.currentThread());
                    return true;
                }
                return false;
            }
    
            //释放锁，将状态设置为0
            @Override
            protected boolean tryRelease(int arg) { 
                if(getState() == 0)
                    throw new IllegalArgumentException();
                setExclusiveOwnerThread(null);
                setState(0);
                return true;
            }
            
            //返回一个Condition，每个condition都包含一个condition队列
            Condition newCondition(){ 
                return new ConditionObject();
            }
        }
        
        //将操作代理到Sync上
        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 boolean isLocked(){ 
            return sync.isHeldExclusively();
        }
        
        public boolean hasQueuedThreads(){ 
            return sync.hasQueuedThreads();
        }
    }

上述示例中，独占锁Mutex是一个自定义同步组件，它在同一时刻只允许一个线程占有锁。Mutex中定义了一个静态内部类，该内部类继承了同步器并实现了独占式获取和释放同步状态。tryAcquire(int acquires)方法中，如果经过CAS设置成功（同步状态设置为1），则代表获取了同步状态，而在tryRelease(int releases)方法中只是将同步状态重置为0。用户使用Mutex时并不会直接和内部同步器的实现打交道，而是调用Mutex提供的方法，在Mutex的实现中，以获取锁的lock()方法为例，只需要在方法实现中调用同步器的模板方法acquire(int args)即可，当前线程调用该方法获取同步状态失败后会被加入到同步队列中等待，这样就大大降低了实现一个可靠自定义同步组件的门槛。

[20200120173803596.png]: /images/20210813/466094c06aee40fcbdd8c14172c11390.png
[20200120173858992.png]: /images/20210813/6c9473267462460f9eea3af2f59b1ca6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbGRfX19wbGF5_size_16_color_FFFFFF_t_70]: /images/20210813/6b6a848927764d46a3c3273cd2a709fd.png