AQS简介

末蓝、 2022-05-25 00:16 189阅读 0赞

## AQS简介 ##

> **AQS，AbstractQueuedSynchronizer，即队列同步器**  
> **AQS即是AbstractQueuedSynchronizer，一个用来构建锁和同步工具的框架，包括常用的ReentrantLock、CountDownLatch、Semaphore等**  
> **AQS功能可以分为两类：独占锁和共享锁**

它是构建锁或者其他同步组件的基础框架（如ReentrantLock、ReentrantReadWriteLock、Semaphore等），JUC并发包的作者（Doug Lea）期望它能够成为实现大部分同步需求的基础。它是JUC并发包中的核心基础组件。

AQS解决了子类实现同步器时涉及到的大量细节问题，例如获取同步状态、FIFO同步队列。基于AQS来构建同步器可以带来很多好处。它不仅能够极大地减少实现工作，而且也不必处理在多个位置上发生的竞争问题。

在基于AQS构建的同步器中，只能在一个时刻发生阻塞，从而降低上下文切换的开销，提高了吞吐量。同时在设计AQS时充分考虑了可伸缩行，因此J.U.C中所有基于AQS构建的同步器均可以获得这个优势。

> **AQS的主要使用方式是继承，子类通过继承同步器并实现它的抽象方法来管理同步状态。**

> **AQS使用一个int类型的成员变量state来表示同步状态，当state = 1时表示已经获取了锁，当state = 0时表示释放了锁。**

它提供了三个方法（getState()、setState(int newState)、compareAndSetState(int expect,int update)）来对同步状态state进行操作，当然AQS可以确保对state的操作是安全的。

AQS通过内置的FIFO同步队列来完成资源获取线程的排队工作，如果当前线程获取同步状态失败（锁）时，AQS则会将当前线程以及等待状态等信息构造成一个节点（Node）并将其加入同步队列，同时会阻塞当前线程，当同步状态释放时，则会把节点中的线程唤醒，使其再次尝试获取同步状态。

### AQS 定义两种资源共享方式 ###

*  Exclusive 独占资源-ReentrantLock  
    Exclusive（独占，只有一个线程能执行，如 ReentrantLock）
 *  Share 共享资源-Semaphore/CountDownLatch  
    Share（共享，多个线程可同时执行，如 Semaphore/CountDownLatch）
 *  ReentrantReadWriteLock 实现独占和共享两种方式

## AQS 组件总结 ##

*  Semaphore(信号量)-允许多个线程同时访问： synchronized 和 ReentrantLock 都是一次只允许一个线程访问某个资源，Semaphore(信号量)可以指定多个线程同时访问某个资源。
 *  CountDownLatch （倒计时器）： CountDownLatch是一个同步工具类，用来协调多个线程之间的同步。这个工具通常用来控制线程等待，它可以让某一个线程等待直到倒计时结束，再开始执行。
 *  CyclicBarrier(循环栅栏)： CyclicBarrier 和 CountDownLatch 非常类似，它也可以实现线程间的技术等待，但是它的功能比 CountDownLatch 更加复杂和强大。主要应用场景和 CountDownLatch 类似。CyclicBarrier 的字面意思是可循环使用（Cyclic）的屏障（Barrier）。它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。CyclicBarrier默认的构造方法是 CyclicBarrier(int parties)，其参数表示屏障拦截的线程数量，每个线程调用await()方法告诉 CyclicBarrier 我已经到达了屏障，然后当前线程被阻塞。

## AQS主要方法 ##

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

/** * The synchronization state. */
        private volatile int state;
        /** * @return current state value */
        protected final int getState() { 
            return state;
        }
    
        /** * @param newState the new state value */
        protected final void setState(int newState) { 
            state = newState;
        }
    
        protected final boolean compareAndSetState(int expect, int update) { 
            // See below for intrinsics setup to support this
            return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
        }

*  tryAcquire(int arg)：独占式获取同步状态，获取同步状态成功后，其他线程需要等待该线程释放同步状态才能获取同步状态；
 *  tryRelease(int arg)：独占式释放同步状态；
 *  tryAcquireShared(int arg)：共享式获取同步状态，返回值大于等于0则表示获取成功，否则获取失败；
 *  tryReleaseShared(int arg)：共享式释放同步状态；
 *  isHeldExclusively()：当前同步器是否在独占式模式下被线程占用，一般该方法表示是否被当前线程所独占；
 *  acquire(int arg)：独占式获取同步状态，如果当前线程获取同步状态成功，则由该方法返回，否则，将会进入同步队列等待，该方法将会调用可重写的tryAcquire(int arg)方法；
 *  acquireInterruptibly(int arg)：与acquire(int arg)相同，但是该方法响应中断，当前线程为获取到同步状态而进入到同步队列中，如果当前线程被中断，则该方法会抛出InterruptedException异常并返回；
 *  tryAcquireNanos(int arg,long nanos)：超时获取同步状态，如果当前线程在nanos时间内没有获取到同步状态，那么将会返回false，已经获取则返回true；
 *  acquireShared(int arg)：共享式获取同步状态，如果当前线程未获取到同步状态，将会进入同步队列等待，与独占式的主要区别是在同一时刻可以有多个线程获取到同步状态；
 *  acquireSharedInterruptibly(int arg)：共享式获取同步状态，响应中断；
 *  tryAcquireSharedNanos(int arg, long nanosTimeout)：共享式获取同步状态，增加超时限制；
 *  release(int arg)：独占式释放同步状态，该方法会在释放同步状态之后，将同步队列中第一个节点包含的线程唤醒；
 *  releaseShared(int arg)：共享式释放同步状态；

## AQS锁用法 ##

*  ReentrantLock

public static void main(String[] args){ 
        ReentrantLock lock=new ReentrantLock();
        try { 
            if (lock.tryLock()){ 
                //业务逻辑处理
            }
        } catch (Exception e) { 
            e.printStackTrace();
        } finally { 
            lock.unlock();
        }
    }

*  Semaphore

public static void main(String[] args){ 
        // 最大同时能接收500个请求
        Semaphore semaphore=new Semaphore(500);
        try { 
            if (semaphore.tryAcquire()){ 
                //业务逻辑处理
            }
        } catch (Exception e) { 
            e.printStackTrace();
        } finally { 
            semaphore.release();
        }
    }

*  CountDownLatch

/** * @author yanyugang * @description ${todo} * @date 2019/9/6 20:49 */
    public class CountDownLatchTest { 
    
        public static void main(String[] args) throws InterruptedException { 
            System.out.println("====begin====");
    
            // 匿名内部类
            // 当前线程需要等待的线程数
            CountDownLatch countDownLatch = new CountDownLatch(2) { 
                @Override
                public void await() throws InterruptedException { 
                    super.await();
                    System.out.println(Thread.currentThread().getName() + " count down is ok");
                }
            };
    
            Thread thread1 = new Thread(new Runnable() { 
                @Override
                public void run() { 
                    try { 
                        Thread.sleep(1000);
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + " is done");
                    // 释放锁
                    countDownLatch.countDown();
                }
            }, "thread1");
    
            Thread thread2 = new Thread(new Runnable() { 
                @Override
                public void run() { 
                    try { 
                        Thread.sleep(2000);
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + " is done");
                    // 释放锁
                    countDownLatch.countDown();
                }
            }, "thread2");
    
            thread1.start();
            thread2.start();
            // Causes the current thread to wait until the latch has counted down to zero
            countDownLatch.await();
            System.out.println("====end====");
        }
    }

--------------------

参考文档：

1.  http://cmsblogs.com/?p=2174