AQS

最新推荐文章于 2023-01-10 18:24:38 发布

白嫖小孙子

最新推荐文章于 2023-01-10 18:24:38 发布

阅读量196

点赞数

分类专栏：多线程文章标签： java

本文链接：https://blog.csdn.net/weixin_46489622/article/details/115191086

版权

多线程专栏收录该内容

6 篇文章 0 订阅

订阅专栏

可重入锁

显示锁ReentrantLock和隐显锁synchronized 都是可重入锁，可重入锁从一定程度上可以避免死锁

package ss;

import java.util.concurrent.locks.ReentrantLock;

/**
 * 肥蛋
 * 2021/3/24
 */
public class RLock {
    static ReentrantLock lock = new ReentrantLock();
    public static void main(String[] args) {
        RLock rLock = new RLock();
        rLock.m1();

    }
    public void m1(){
        lock.lock();
        System.out.println("m1");
        m2();
        lock.unlock();
    }
    public  void m2(){
        lock.lock();
        System.out.println("m2");
        lock.unlock();
    }
}

输出结果

m1
m2

可重入锁原理

重入锁实现可重入性原理或机制是：每一个锁关联一个线程持有者和计数器state，当计数器state为 0 时表示该锁没有被任何线程持有，那么任何线程都可能获得该锁而调用相应的方法；当某一线程请求成功后，JVM会记下锁的持有线程，并且将计数器置为 1；此时其它线程请求该锁，则必须等待；而该持有锁的线程如果再次请求这个锁，就可以再次拿到这个锁，同时计数器会递增；当线程退出同步代码块时，计数器会递减，如果计数器为 0，则释放该锁。

LockSuppot

java.util.concurrent.locks.LockSupport 用于创建锁和其他同步类的基本线程阻塞原语，这个类与每个使用它的线程相关联一个许可证。

LockSupport中的park()和unpark()的作用分别是阻塞线程和解除阻塞线程

解释：

LockSupport类使用了一种名为Permit (许可)的概念来做到阻塞和唤醒线程的功能，每个线程都有一个许可(permit),
permit只有两个值1和零，默认是零。可以把许可看成是一种(0,1)信号量(Semaphore)，但与Semaphore不同的是，许可的累加上限是1.

1.三种线程阻塞和唤醒

方式1:使用Object中的wait()方法让线程等待，使用0bject中的notify()方法唤醒线程

方式2:使用JUC包中Condition的await()方法让线程等待，使用signal()方法唤醒线程

方式3: LockSupport类可以阻塞当前线程以及唤醒指定被阻塞的线程

注意：

方法一和方法二，线程先要获得并持有锁，必须在锁块(synchronized或lock)中，必须要先等待后唤醒，线程才能够被唤醒

方法三线程不需要在锁块中，并且可以先唤醒。

2.park()和unpark()方法

park()

permit默认是0，所以一 -开始调用park()方法，当前线程就会阻塞，直到别的线程将当前线程的permit设置为1时，park方法会被唤醒，
然后会将permit再次设置为0并返回。

unpark()

调用unpark(thread)方法后，就会将thread线程的许可permit设置成1(注意多次调用unpark方法，不会累加，permit值还是1)会自动唤醒thread线程，即之前阻塞中的LockSupport.park()方法会立即返回。

3.总结

LockSupport是用来创建锁和其他同步类的基本线程阻塞原语。

LockSupport是一个线程阻塞工具类，所有的方法都是静态方法，可以让线程在任意位置阻塞，阻塞之后也有对应的唤醒方法。归根
结底，LockSupport调用的Unsafe中的native代码。

LockSupport提供park()和unpark()方法实现阻塞线程和解除线程阻塞的过程。

LockSupport和每个使用它的线程都有一个许可(permit)关联。permit相当于1，0的开关，默认是0，
调用一次unpark就加1变成1,
调用一次park会消费permit,也就是将1变成0，同时park立即返回。
如再次调用park会变成阻塞(因为permit为零了会阻塞在这里，一直到permit变为1)，这时调用unpark会把permit置为1。
每个线程都有一个相关的permit, permit最多只有一个，重复调用unpark也不会积累凭证。

形象的理解
线程阻塞需要消耗凭证(permit)，这个凭证最多只有1个。
当调用park方法时
如果有凭证，则会直接消耗掉这个凭证然后正常退出;
如果无凭证，就必须阻塞等待凭证可用;
而unpark则相反，它会增加一个凭证，但凭证最多只能有1个，累加无效。

4.面试

为什么可以先唤醒线程后阻塞线程?

因为unpark获得了一个凭证，之后再调用park方法，就可以名正言顺的凭证消费，故不会阻塞。

为什么唤醒两次后阻塞两次，但最终结果还会阻塞线程?

因为凭证的数量最多为1，连续调用两次unpark和调用一次unpark效果-样，只会增加一个凭证;
而调用两次park却需要消费两个凭证，证不够，不能放行。

AQS

字面意思

AbstractQueuedSynchronizer

抽象的队列同步器

在对锁的抢占提前定义的父类模板

技术解释

是用来构建锁或者其它同步器组件的重量级基础框架及整个JUC体系的基石，
通过内置的FIFO队列来完成资源获取线程的排队工作，并通过一个int类型变量state表示持有锁的状态

在这里插入图片描述

AQS相关的类

在这里插入图片描述

AQS能干嘛？

AQS负责管理加锁的阻塞，有阻塞就需要排队，实现排队必然需要有某种形式的队列来进行管理

抢到资源的线程直接使用处理业务逻辑，抢不到资源的必然涉及一种排队等候机制。抢占资源失败的线程继续去等待(类似银行业务办理窗口都满了，暂时没有受理窗口的顾客只能去候客区排队等候)，但等候线程仍然保留获取锁的可能且获取锁流程仍在继续(候客区的顾客也在等着叫号，轮到了再去受理窗口办理业务)。

既然说到了排队等候机制，那么就一定会有某种队列形成，这样的队列是什么数据结构呢?

如果共享资源被占用，就需要一定的阻塞等待唤醒机制来保证锁分配。这个机制主要用的是CLH队列的变体实现的，将暂时获取不到锁的线程加入到队列中，这个队列就是AQS的抽象表现。它将请求共享资源的线程封装成队列的结点(Node) ，通过CAS、自旋以及LockSupport.park()的方式，维护state变量的状态，使并发达到同步的控制效果。

在这里插入图片描述

AQS关系图

在这里插入图片描述

API层面调用ReentranLock,ReentranLock调用Sync，Sync调用AQS。

AQS内部

state变量

state为1，代表有线程持有锁

state为0，代表当前锁没有线程持有。

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sl0C3BwW-1616688054862)(C:\Users\孙晨鱼\Desktop\孙晨雨4.7\新建文件夹\笔记\JAva\图片笔记\图片\CLH队列.png)]$

有阻塞就需要排队，排队就需要实现队列

AQS = state变量 + CLH队列

nodle节点

在这里插入图片描述

同步队列基本结构

在这里插入图片描述

ReentrantLock开始解读AQS

1.Lock关系图

Lock接口的实现类，基本都是通过聚合了一个队列同步器（AbstractQueuedSynchronizer）的子类（Sync）完成线程访问控制的

2.公平锁和非公平锁

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nqZn48zr-1616688054870)(C:\Users\孙晨鱼\Desktop\孙晨雨4.7\新建文件夹\笔记\JAva\图片笔记\图片\公平锁和非公平锁.png)]$

可以明显看出公平锁与非公平锁的lock()方法唯一的区别就在于公平锁在获取同步状态时多了一个限制条件:
hasQueuedPredecessors()
hasQueuedPredecessors是公平锁加锁时判断等待队列中是否存在有效节点的万法

对比公平锁和非公平锁的tryAcquire()尝试抢占锁方法的实现代码，其实差别就在于非公平锁获取锁时比公平锁中少了一个判断!hasQueuedPredecessors()
hasQueuedPredecessors()中判断了是否需要排队，导致公平锁和非公平锁的差异如下:

公平锁:公平锁讲究先来先到，线程在获取锁时，如果这个锁的等待队列中已经有线程在等待，那么当前线程就会进入等待队列中;

非公平锁:不管是否有等待队列，如果可以获取锁，则立刻占有锁对象。也就是说队列的第一个排队线程在unpark)，之后还是需要竞争锁(存在线程竞争的情况下)

(1). 本次讲解我们走最常用的，lock/unlock作为案例突破口
(2). 我相信你应该看过源码了，那么AQS里面有个变量叫State，它的值有几种？3个状态：没占用是0，占用了是1，大于1是可重入锁
(3). 如果AB两个线程进来了以后，请问这个总共有多少个Node节点？答案是3个,其中队列的第一个是傀儡节点(哨兵节点)
业务图：

3.代码

package ss;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 肥蛋
 * 2021/3/25
 */
public class AQSDemo {
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        //带入一个银行办理业务的案例来模拟我们的AQS如何进行线程的管理和通知唤醒机制
        //3个线程模拟3个来银行网点，受理窗口办理业务的顾客
        //A顾客就是第一个顾客，此时受理窗口没有任何人，A可以直接去办理
        new Thread(() -> {
            lock.lock();
            try{
                System.out.println("-----A thread come in");

                try { TimeUnit.MINUTES.sleep(20); }catch (Exception e) {e.printStackTrace();}
            }finally {
                lock.unlock();
            }
        },"A").start();

        //第二个顾客，第二个线程---》由于受理业务的窗口只有一个(只能一个线程持有锁)，此时B只能等待，
        //进入候客区
        new Thread(() -> {
            lock.lock();
            try{
                System.out.println("-----B thread come in");
            }finally {
                lock.unlock();
            }
        },"B").start();

        //第三个顾客，第三个线程---》由于受理业务的窗口只有一个(只能一个线程持有锁)，此时C只能等待，
        //进入候客区
        new Thread(() -> {
            lock.lock();
            try{
                System.out.println("-----C thread come in");
            }finally {
                lock.unlock();
            }
        },"C").start();
    }
}

4.lock()方法

lock.lock()；非公平锁源码

static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;
        final void lock() {
            //判断第一个线程进来，期望state的值是0，修改为1
            if (compareAndSetState(0, 1))
                //设当前线程为独占线程
                setExclusiveOwnerThread(Thread.currentThread());
            else
                 //其余线程进来，走这个方法，尝试抢占锁
                acquire(1);
        }
}

protected final boolean compareAndSetState(int expect, int update) {
    	//比较并交换，this当前对象，stateOffset，state的内存偏移量，期望值，修改值
    	//比较并交换成功，返回ture
        return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
    }

lock()方法执行完，第一个线程(A)持有锁，并设置为独占锁线程。

在这里插入图片描述

5.acquire(1)方法

此时B线程进来，state变量值为1，只能走acquire(1)方法

	static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;
        final void lock() {
            //判断第一个线程进来，期望state的值是0，修改为1
            if (compareAndSetState(0, 1))
                //设当前线程为独占线程
                setExclusiveOwnerThread(Thread.currentThread());
            else
                 //其余线程进来，走这个方法，尝试抢占锁
                acquire(1);
        }

        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }

public final void acquire(int arg) {
    //tryAcquire(arg)如果返回true，表示当前线程抢占到了锁，！true表示false，因为是&&后面不会再走了
    //tryAcquire(arg)如果返回false，表示当前线程抢占锁失败，准备进入队列等待
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

6.tryAcquire()

①.本次走非公平锁方向

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-L3Ax78wo-1616688054873)(C:\Users\孙晨鱼\Desktop\孙晨雨4.7\新建文件夹\笔记\JAva\图片笔记\图片\try.png)]$

②. nonfairTryAcquire(acquires)

inal boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    //获取当前state的值
    int c = getState();
    //如果c=0，说明A办理完业务了，B准备抢占
    if (c == 0) {
        //判断当前state变量为0，就修改为1
        if (compareAndSetState(0, acquires)) {
            //修改B线程为当前独占锁线程
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    //这种情况是可重入锁原理
    //如果是当前线程A，来再次获得锁
    else if (current == getExclusiveOwnerThread()) {
        //c = 1     acq = 1
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        //设置state为2，表示可重入锁
        setState(nextc);
        return true;
    }
    //如果有当前线程持有锁，并且有其余线程尝试抢占锁的线程，返回false
    return false;
}

7.addWaiter(Node.EXCLUSIVE)

①. addWaiter(Node mode )
双向链表中，第一个节点为虚节点(也叫哨兵节点)，其实并不存储任何信息，只是占位。真正的第一个有数据的节点，是从第二个节点开始的

private Node addWaiter(Node mode) {
    //创建一个节点，节点里存当前线程 mode= Node.EXCLUSIVE
    Node node = new Node(Thread.currentThread(), mode);
   //这时候B节点进来 tail指针指向null
   //当线程C进来的时候, tail= b线程指向,在if中会做如下操作:
	//(1).把线程c的prev指向线程B；(2).通过compareAndSetTai将tail指向C；(3).pred.next= node //将b的next节点指向C
    Node pred = tail;
    //当没有节点的时候
    if (pred != null) {
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    enq(node);
    return node;
}

enq(node)

只有第二个线程进来才会走enq，创建哨兵节点，并且哨兵节点指向ThreadB节点

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-96BGEi0N-1616688054873)(C:\Users\孙晨鱼\Desktop\孙晨雨4.7\新建文件夹\笔记\JAva\图片笔记\图片\enq.png)]$

8.acquireQueued(addWaiter(Node.EXCLUSIVE), arg)

①. acquireQueued
(会调用如下方法：shouldParkAterFailedAcquire和parkAndCheckInterrupt | setHead(node) )
②. shouldParkAfterFailedAcquire

final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
            final Node p = node.predecessor();
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}