秋招突击——7/19——队列同步器AQS学习

文章目录

- 引言
- 基础知识
- - 简介
  - AQS接口和示例
  - - 第一类：访问和修改同步状态的方法
    - 第二类，5个重写的方法
    - 第三类，9个模板方法
  - 队列同步器实现原理
  - - 同步队列
    - 独占式同步获取和释放
    - 共享式同步获取和释放
    - 独占式同步获取和释放
- 相关面试题
- - 怎么理解Lock和AQS的关系
  - 什么是AQS
  - AQS是怎么实现同步管理的？底层数据结构？
  - AQS有哪些核心方法
- 总结

引言

学了锁，学了多线程编程，学了线程池，发现很多都提到了AQS，现在来补一下，也是填一下以前留下的坑。
- 坑位
还是跟以前一样，先过一遍基础知识，然后再过一遍相关的面试题

基础知识

简介

队列同步器AbstractQueuedSynchronizer
- 构建锁和其他同步组建的基础框架
  - 使用int变量表示同步状态，通过内置的队列完成线程排队工作，是实现大部分同步需求的基础
  - 仅仅定义若干同步状态的获取和释放方法，来实现线程同步，没有实现任何接口
  - 支持独占式和共享式获取同步状态
- 使用方式：继承
  - 子类通过继承并实现方法管理同步状态，使用getState（），setState（）和compareAndSetState来修改状态

AQS接口和示例

AQS的实现采用的是模板模式，使用他对外提供的三类方法来实现一个同步组件。
- 这里又不知道模板模式了，得去好好学一下了，学习链接
三类方法分别如下
- 第一类：同步器提供的用于访问和修改同步状态的三个方法
- 第二类：继承AQS并重写的5个方法
- 第三类：9个模板方法，用来组合AQS形成自定义的同步组件
  这里给一个自定义的锁的样例mutex
第一步先在同步器中创建一个内部类继承并实现AQS，重写对应5个方法
调用9个模板方法，组合对应同步器的逻辑

在这里插入图片描述

第一类：访问和修改同步状态的方法

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

getState：获取当前同步状态
setState（int newState）：设置当前同步状态
CompareAndSetState（int expect，int update）：使用CAS设置当前状态，保证状态设置的原子性

第二类，5个重写的方法

isHeldExclusively：
- 判定该线程是否正在独享资源，只有用到condition的时候，才需要实现它
tryAcquire（int）
- 独占的方式，尝试获取资源，成功就返回true，失败就返回false
tryRelease（int）
- 独占的方式，尝试释放资源，成功就返回true，失败就返回false
tryAcquireShared
- 共享方式，尝试获取资源
- 负数表示失败，0表示成功但是没有可用资源剩余，正数表示成功并且有剩余资源
tryReleaseShared
- 共享方式，尝试释放资源
- 成功返回true，失败返回false

第三类，9个模板方法

模板方法主要分成三类

独占式获取和释放同步状态
共享式获取和释放同步状态
查询同步队列中的等待线程

第一类，独占式获取和释放同步状态

void acquire
- 独占式获取同步状态，获取成功由该方法返回，否则进入同步队列等待
- 调用重写的tryAcquire方法
void acquireInterruptibly
- 同上，但是支持响应中断
- 当前线程未获取到同步状态，而进入同步队列中，如果线程被中断，该方法抛出InterruptedException
void tryAcquireNanos
- 同上，但是支持响应中断，而且增加了超时机制
- 当前线程在超时时间内没有获取到同步状态，就会返回false，否则返回true
bool release
- 独占式释放同步状态
- 释放同步状态后，将同步队列中的第一个节点唤醒

第二类，共享式获取和释放同步状态

void acquireShared
- 共享式获取同步状态，获取成功由该方法返回，否则进入同步队列等待
- 与独占式的区别是同一时刻，有多个线程获取同步状态
void acquireSharedInterruptibly
- 同上，但是支持响应中断
- 当前线程未获取到同步状态，而进入同步队列中，如果线程被中断，该方法抛出InterruptedException
void tryAcquireSharedNanos
- 同上，但是支持响应中断，而且增加了超时机制
- 当前线程在超时时间内没有获取到同步状态，就会返回false，否则返回true
bool releaseShared
- 共享式释放同步状态
- 释放同步状态后，将同步队列中的第一个节点唤醒

第三类、获取同步队列中的线程

collection getQueueThread
- 获取等待在同步队列上的线程的集合

这里给一个自定义的锁的样例mutex

第一步先在同步器中创建一个内部类继承并实现AQS，重写对应5个方法
调用9个模板方法，组合对应同步器的逻辑

在这里插入图片描述
具体代码

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

public class Mutex implements Lock {

    // 定义一个静态内部类，用来继承AQS
    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 IllegalMonitorStateException();
            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();
    }
}

总结
基本步骤如下

继承Lock接口
定义一个内部静态类AQS的子类，重写5个重写方法，调用3个状态修改函数实现
使用9个模板方法实现Lock规定的接口方法
- 将操作代理到AQS子类Sync上，利用Sync的14种方法来实现Lock

队列同步器实现原理

同步队列

队列节点

节点Node是构成同步队列的基础，获取同步状态失败的线程将会被包装成一个节点，加入到同步队列的尾部。
属性
- waitStatus等待状态
  - cancelled表示线程超时或者中断，从队列中取消等待
  - signal表示后继节点处于等待状态，当前节点释放同步状态会通知后继节点
  - condition表示节点在等待队列中，节点等待在Condition对象为锁的等待队列上，当其他线程对Condition调用signal方法时，该节点将等待队列转移到同步队列，加入到同步状态的获取中。
  - propagate表示下一个共享式同步状态将会无条件传播下去
- prev和next：表示同步队列中的前驱节点和后继节点
- nextWaiter：等待队列中的后继节点

独占式同步获取和释放

获取同步状态时，主要是通过维护一个同步队列实现
- 获取状态失败的线程会加入到同步队列中，自旋并尝试获取同步状态
- 释放同步状态，同步器调用tryRelease方法，释放同步状态，唤醒后继节点

共享式同步获取和释放

共享式同步获取实现
- 调用tryAcquireShared方法，根据返回的int值判定，大于等于零表示获取成功，这个值表示剩余的资源数。
调用releaseShared方法释放同步状态

独占式同步获取和释放

使用理解
- 强于Synchronized关键字，能够实现在指定时间内获取同步状态，调用同步器地doAcquireNanos实现
- 支持中断
设置时间过短
- 如果设置时间过短，会进入快速自旋过程

总结

我觉这些框架的东西不是很好理解，过分偏向于底层了，然后理解起来有比较费劲，背起来也比较难，问的也比较少，但是总是在很多地方有体现，这里还是得学习一下！
这个过了，多线程编程算是过了，还有一些并发容器（ConcurrentHashMap和CopyOnWriteList）以及并发工具类没有实现，这里还是抽空再看吧！感觉问到的比较少！
招工作真的不容易呀，学的我想死，每天的学习任务都好重！还是害怕找不到好工作！白读了研究生！