📝个人主页：五敷有你      

 🔥系列专栏：并发编程

⛺️稳中求进，晒太阳

1. 概述

全称是 AbstractQueuedSynchronizer，是阻塞式锁和相关的同步器工具的框架

特点：

• 用 state 属性来表示资源的状态（分独占模式和共享模式），子类需要定义如何维护这个状态，控制如何获取锁和释放锁
  • getState - 获取 state 状态
  • setState - 设置 state 状态
  • compareAndSetState - cas 机制设置 state 状态
  • 独占模式是只有一个线程能够访问资源，而共享模式可以允许多个线程访问资源
• 提供了基于 FIFO 的等待队列，类似于 Monitor 的 EntryList
• 条件变量来实现等待、唤醒机制，支持多个条件变量，类似于 Monitor 的 WaitSet

子类主要实现这样一些方法（默认抛出 UnsupportedOperationException）

• tryAcquire
• tryRelease
• tryAcquireShared
• tryReleaseShared
• isHeldExclusively

获取锁的姿势

// 如果获取锁失败
if (!tryAcquire(arg)) { 
// 入队, 可以选择阻塞当前线程 park unpark
}

释放锁的姿势

// 如果释放锁成功
if (tryRelease(arg)) { 
// 让阻塞线程恢复运行
}

2. 实现不可重入锁

自定义同步器

//同步器类
class MySync extends AbstractQueuedSynchronizer {
    @Override
    protected boolean tryAcquire(int arg) {
        if (compareAndSetState(0,1)) {
            setExclusiveOwnerThread(Thread.currentThread());
            return true;
        }
        return false;
    }

    @Override
    protected boolean tryRelease(int arg) {
        setExclusiveOwnerThread(null);
       setState(0);

       return true;
    }

    @Override //是否持有独占锁
    protected boolean isHeldExclusively() {
        if(getExclusiveOwnerThread()!=null){
            return true;
        }
        return false;
    }
    public Condition newCondition(){
        return  new ConditionObject();
    }

}

自定义锁

有了自定义同步器，很容易复用 AQS ，实现一个功能完备的自定义锁

public class MyLock implements Lock {
    MySync mySync=new MySync();

@Override  //加锁，不成功进入等待队列等待
public void lock() {
   mySync.acquire(1);

}

@Override //加锁，可以被打断
public void lockInterruptibly() throws InterruptedException {
    mySync.acquireInterruptibly(1);
}

@Override //尝试加锁（一次）
public boolean tryLock() {
    mySync.tryAcquire(1);
    return true;
}

@Override //尝试加锁（带超时时间）
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
   mySync.tryAcquireNanos(1,unit.toNanos(time));
   return true;
}

@Override //解锁
public void unlock() {
    mySync.release(1);
}

@Override  //创建条件变量
public Condition newCondition() {
    return mySync.newCondition();
}

}

测试一下

public static void main(String[] args) {
    Lock myLock=new MyLock();
    new Thread(()->{
        myLock.lock();
        try {
            System.out.println("locking...");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }finally {
            System.out.println("unlock...");
            myLock.unlock();
        }


    },"t1").start();
    new Thread(()->{
        myLock.lock();
        try {
            System.out.println("加锁...");

        }finally {
            System.out.println("解锁...");
            myLock.unlock();
        }
    },"t2").start();

}

心得

起源

早期程序员会自己通过一种同步器去实现另一种相近的同步器，例如用可重入锁去实现信号量，或反之。这显然不够优雅，于是在 JSR166（java 规范提案）中创建了 AQS，提供了这种通用的同步器机制。

目标

AQS 要实现的功能目标

• 阻塞版本获取锁 acquire 和非阻塞的版本尝试获取锁 tryAcquire
• 获取锁超时机制
• 通过打断取消机制
• 独占机制及共享机制
• 条件不满足时的等待机制

设计

AQS 的基本思想其实很简单

获取锁的逻辑

while(state 状态不允许获取) {
     if(队列中还没有此线程) { 
         入队并阻塞 
         }
    }
 当前线程出队

释放锁的逻辑

if(state 状态允许了) {
     恢复阻塞的线程(s)
 }

要点

• 原子维护 state 状态
• 阻塞及恢复线程
• 维护队列

1) state 设计

• state 使用 volatile 配合 cas 保证其修改时的原子性
• state 使用了 32bit int 来维护同步状态，因为当时使用 long 在很多平台下测试的结果并不理想

2) 阻塞恢复设计

• 早期的控制线程暂停和恢复的 api 有 suspend 和 resume，但它们是不可用的，因为如果先调用的 resume那么 suspend 将感知不到
• 解决方法是使用 park & unpark 来实现线程的暂停和恢复，具体原理在之前讲过了，先 unpark 再 park 也没问题
• park & unpark 是针对线程的，而不是针对同步器的，因此控制粒度更为精细
• park 线程还可以通过 interrupt 打断

3) 队列设计

• 使用了 FIFO 先入先出队列，并不支持优先级队列
• 设计时借鉴了 CLH 队列，它是一种单向无锁队列

主要用到AQS的并发工具类