从代码应用上看看AQS是个什么dog

JAVA并发包里大多数都用到CAS和AQS的技术，用来解决并发情况下多个线程碰撞的问题，也就是多线程情况下执行顺序的问题和幂等的问题。

AQS简单说是通过队列来存放线程，按照左到右，右到左的顺序实现线程执行顺序。下图是他发的原理图，一个双端队列。

AQS是将每一条请求共享资源的线程封装成一个CLH锁队列的一个结点（Node），来实现锁的分配。

用大白话来说，AQS就是基于CLH队列，用volatile修饰共享变量state，线程通过CAS去改变状态符，成功则获取锁成功，失败则进入等待队列，等待被唤醒。

**注意：AQS是自旋锁：**在等待唤醒的时候，经常会使用自旋（while(!cas())）的方式，不停地尝试获取锁，直到被其他线程获取成功

数据结构是俩个单向链表。

 

看一张图（摘自）先弄明白AQS、公平锁、非公平锁的原理：

 

 

下面通过伪代码，进行更加直观的比较：

// **************************Synchronized的使用方式**************************
// 1.用于代码块
synchronized (this) {}
// 2.用于对象
synchronized (object) {}
// 3.用于方法
public synchronized void test () {}
// 4.可重入
for (int i = 0; i < 100; i++) {
	synchronized (this) {}
}
// **************************ReentrantLock的使用方式**************************
public void test () throw Exception {
	// 1.初始化选择公平锁、非公平锁
	ReentrantLock lock = new ReentrantLock(true);
	// 2.可用于代码块
	lock.lock();
	try {
		try {
			// 3.支持多种加锁方式，比较灵活; 具有可重入特性
			if(lock.tryLock(100, TimeUnit.MILLISECONDS)){ }
		} finally {
			// 4.手动释放锁
			lock.unlock()
		}
	} finally {
		lock.unlock();
	}
}

AQS同时提供了互斥模式（exclusive）和共享模式（shared）两种不同的同步逻辑。 

package LearnCases;

import java.util.concurrent.locks.AbstractQueuedSynchronizer;

/**
 * Created with IntelliJ IDEA.
 *
 * @Auther: suibin
 * @Date: 2021/05/13/16:19
 * @Description:AQS是个什么狗？AbstractQueuedSynchronizer的缩写。AQS核心思想是，如果被请求的共享资源空闲，那么就将当前请求资源的线程设置为有效的工作线程，将共享资源设置为锁定状态；
 * 如果共享资源被占用，就需要一定的阻塞等待唤醒机制来保证锁分配。
 * 这个机制主要用的是CLH队列的变体实现的，将暂时获取不到锁的线程加入到队列中。
 * CLH：Craig、Landin and Hagersten队列，是单向链表，AQS中的队列是CLH变体的虚拟双向队列（FIFO）也叫双端队列，AQS是通过将每条请求共享资源的线程封装成一个节点来实现锁的分配。
 * AQS使用一个Volatile的int类型的成员变量来表示同步状态，通过内置的FIFO队列来完成资源获取的排队工作，通过CAS完成对State值的修改。
 */

public class LeeLock  {

    private static class Sync extends AbstractQueuedSynchronizer {
        //独占方式。arg为获取锁的次数，尝试获取资源，成功则返回True，失败则返回False。
        @Override
        protected boolean tryAcquire (int arg) {
            return compareAndSetState(0, 1);
        }
        //独占方式。arg为释放锁的次数，尝试释放资源，成功则返回True，失败则返回False。
        @Override
        protected boolean tryRelease (int arg) {
            setState(0);
            return true;
        }

        //共享方式。arg为获取锁的次数，尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。
        @Override
        protected int tryAcquireShared(int arg) {
            return 0;
        }
        //共享方式。arg为释放锁的次数，尝试释放资源，如果释放后允许唤醒后续等待结点返回True，否则返回False。
        protected boolean tryReleaseShared(int arg) {
            return false;
        }

        //当前线程，如果同步是以独占方式进行的，则返回true；其他情况则返回 false
        @Override
        protected boolean isHeldExclusively () {
            return getState() == 1;
        }
    }

    private Sync sync = new Sync();

    public void lock () {
        /*
        * 这是acquire的代码实现，比tryAcquire多了个中断，可以理解比tryAcquire方法是你的锁逻辑，acquire是在你的锁逻辑上帮你考虑了很多健壮性、系统性的处理。
        * public final void acquire(int arg) {
            if (!tryAcquire(arg) &&//独占方式获取锁
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();//中断线程
            }
            static void selfInterrupt() {
            Thread.currentThread().interrupt();//Thread.interrupt 的作用其实也不是中断线程，而是「通知线程应该中断了」，具体到底中断还是继续运行，应该由被通知的线程自己处理。
            * Thread.interrupt原理：一条线程发出终止信号后（中断标志），接收线程并不会立即停止，而是将本次循环的任务执行完，再跳出循环停止线程。
            }
        *
        *
        * */
        sync.acquire(1);
    }

    public void unlock () {
        sync.release(1);
    }
}

 

package LearnCases;

/**
 * Created with IntelliJ IDEA.
 *
 * @Auther: suibin
 * @Date: 2021/05/13/16:20
 * @Description:自定义AQS测试类
 */
public class LeeMain {

    static int count = 0;
    static LeeLock leeLock = new LeeLock();//引入自定义的锁

    public static void main (String[] args) throws InterruptedException {

        Runnable runnable = new Runnable() {
            @Override
            public void run () {
                try {
                    leeLock.lock();//加锁
                    for (int i = 0; i < 10000; i++) {
                        count++;
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    leeLock.unlock();//释放锁
                }

            }
        };
        Thread thread1 = new Thread(runnable);//线程1
        Thread thread2 = new Thread(runnable);//线程2
        thread1.start();//线程加载内存
        thread2.start();//线程加载内存
        thread1.join();//线程执行
        thread2.join();//线程执行
        System.out.println(count);
    }
}

参考：

https://tech.meituan.com/2019/12/05/aqs-theory-and-apply.html