AQS面试题总结

一:线程等待唤醒的实现方法

方式一:使用Object中的wait()方法让线程等待,使用Object中的notify()方法唤醒线程

必须都在synchronized同步代码块内使用,调用wait,notify是锁定的对象;
notify必须在wait后执行才能唤醒;public class LockSupportDemo1 {public static void main(String[] args) {Object objectLock = new Object();/*** t1	 -----------come in* t2	 -----------发出通知* t1	 -------被唤醒*/new Thread(() -> {synchronized (objectLock) {System.out.println(Thread.currentThread().getName() + "\t -----------come in");try {objectLock.wait();} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + "\t -------被唤醒");}}, "t1").start();try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}new Thread(() -> {synchronized (objectLock) {objectLock.notify();System.out.println(Thread.currentThread().getName() + "\t -----------发出通知");}}, "t2").start();}
}

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

必须在lock同步代码块内使用;
signal必须在await后执行才能唤醒;public class LockSupportDemo2 {public static void main(String[] args) {Lock lock = new ReentrantLock();Condition condition = lock.newCondition();new Thread(() -> {lock.lock();try {System.out.println(Thread.currentThread().getName() + "\t -----------come in");condition.await();System.out.println(Thread.currentThread().getName() + "\t -----------被唤醒");} catch (InterruptedException e) {e.printStackTrace();} finally {lock.unlock();}}, "t1").start();try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}new Thread(() -> {lock.lock();try {condition.signal();System.out.println(Thread.currentThread().getName() + "\t -----------发出通知");} finally {lock.unlock();}}, "t2").start();}
}

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

不需要锁块;
unpark()可以在park()前唤醒;public class LockSupportDemo {public static void main(String[] args) {/*** t1	 -----------come in* t2	 ----------发出通知* t1	 ----------被唤醒*/Thread t1 = new Thread(() -> {System.out.println(Thread.currentThread().getName() + "\t -----------come in");try {TimeUnit.SECONDS.sleep(2);} catch (InterruptedException e) {e.printStackTrace();}LockSupport.park();System.out.println(Thread.currentThread().getName() + "\t ----------被唤醒");}, "t1");t1.start();try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}new Thread(() -> {LockSupport.unpark(t1);//指定需要唤醒的线程,可以先给t1发放许可证,t1再被锁定,此时t1可以立马被唤醒System.out.println(Thread.currentThread().getName() + "\t ----------发出通知");}, "t2").start();}
}

二: 介绍一下LockSupport

LockSupport是什么: LockSupport类使用了一种名为Permit(许可)的概念来做到阻塞和唤醒线程的功能,每个线程都有一个许可(Permit),许可证只有两个值,1和0;默认是0,许可证不能超过1;
park()方法:调用park方法,当前线程会阻塞,直到别的线程给当前线程发放peimit,park方法才会被唤醒。
unpack(thread)方法: 调用unpack方法,就会将thread线程的许可证peimit发放,唤醒处于阻塞状态的指定线程。

面试题:
1:LockSupport为什么可以先唤醒线程后阻塞线程但不会阻塞?
答:因为unpark()方法获得了一个许可证,许可证值为1,再调用park()方法,就可消费这个许可证,所以不会阻塞;

2:为什么唤醒两次后阻塞两次,最终还是会阻塞?
答:如果线程A调用两遍park(),线程B调用两边unpark(),那么只会解锁一个park(),因为许可证最多只能为1,不能累加;

三:AQS是什么

AQS使用一个volatile的int类型的成员变量来表示同步状态,通过内置的FIFO队列完成资源获取排队工作,将每条要去抢占资源的线程封装成一个NODE节点来实现锁的分配,通过CAS完成对State值的修改,
AQS的本质是一个双向队列加一个状态为state

五:公平锁与非公平锁的区别

公平锁: 多个线程按照线程调用lock()的顺序去获得锁,线程会直接进入队列去排队,永远都是队列的第一位才能得到锁。

非公平锁: 多个线程去获取锁的时候,会直接去尝试获取,获取不到,再去进入等待队列,如果能获取到,就直接获取到锁。

六: 非公平锁加锁的源码分析

tryAcquire(arg):尝试获取锁
addWaiter(Node.EXCLUSIVE):添加到同步队列
acquireQueued(addWaiter(Node.EXCLUSIVE), arg)):队列里自旋等待获取等

第一步、tryAquire

先获取当前AQS 的state的值,判断是否为0,如果为0表示没有人抢占,此刻他抢占,返回true,抢占锁后就完事了;

   // 这里调用进入非公平锁的tryAcquireprotected final boolean tryAcquire(int acquires) {return nonfairTryAcquire(acquires);}// 具体代码在这里final boolean nonfairTryAcquire(int acquires) {final Thread current = Thread.currentThread();int c = getState();// 若当前无其他线程抢占锁,则抢占;if (c == 0) {if (compareAndSetState(0, acquires)) {setExclusiveOwnerThread(current);return true;}}//如果已获取锁的线程再调用lock()则state值+1,这里就是可重入的原理else if (current == getExclusiveOwnerThread()) {int nextc = c + acquires;if (nextc < 0) // overflowthrow new Error("Maximum lock count exceeded");setState(nextc);return true;}// 都不是则返回falsereturn false;}

第二步、addWaiter

创建队列的节点,首先就先new出来一个节点,由于刚开始当前队列没有节点,因此进入enq()方法;

enq方法插入节点是死循环:
第一次循环,由于tail为空,他先创建一个空的node节点,作为头节点,此时waitStatus=0,然后将head指向该头节点,并将tail指针也指向head;

第二次循环,他将待插入node节点(线程B)的前置指针指向tail指向的节点(头节点),然后CAS将tail指向当前待插入节点(线程B),再让原来的tail指向的节点(头节点)的next域指向当前节点,这样就完成了节点(线程B)插入队尾,完成链式结构,跳出循环;
在这里插入图片描述

private Node addWaiter(Node mode) {// 创建一个节点 modeNode node = new Node(Thread.currentThread(), mode);// Try the fast path of enq; backup to full enq on failureNode pred = tail;// 刚开始tail是null,如果tail有值了就将node插入队尾;if (pred != null) {node.prev = pred;if (compareAndSetTail(pred, node)) {pred.next = node;return node;}}// 若队列为空,则插入节点enq(node);return node;}private Node enq(final Node node) {for (;;) { // 死循环Node t = tail;if (t == null) { // 初始下tail为null,因此创建一个头节点if (compareAndSetHead(new Node()))tail = head;} else {node.prev = t;// 第二次循环,队列不为空,就将该节点插入队尾if (compareAndSetTail(t, node)) {t.next = node;return t;}}}}

第三步:aquireQueued

这个方法依旧是死循环。
第一次循环:首先predecessor()取出的就是前置节点,p就是链表中的头节点,然后进入判断,当前确实是头节点,然后再次尝试tryAcquire(),由于线程A并没有释放锁,因此,只能进入shouldParkAfterFailedAcquire()方法;

第二次循环,再次进入shouldParkAfterFailedAcquire(),这一次由于ws=-1,因此返回true,并进入parkAndCheckInterrupt()方法;这里会调用LockSupport.park()将线程挂起,此刻线程B就阻塞再这里了。
在这里插入图片描述

final boolean acquireQueued(final Node node, int arg) {boolean failed = true;try {boolean interrupted = false;for (;;) {final Node p = node.predecessor();//获取节点的前置节点,线程B获取到的是头节点if (p == head && tryAcquire(arg)) {//由于线程A占用,尝试获取失败setHead(node);p.next = null; // help GCfailed = false;return interrupted;}if (shouldParkAfterFailedAcquire(p, node) &&parkAndCheckInterrupt())// 线程B会进入这里interrupted = true;}} finally {if (failed)cancelAcquire(node);}
}private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {int ws = pred.waitStatus;// 头节点的waitStatus=0if (ws == Node.SIGNAL)// -1return true;if (ws > 0) {do {node.prev = pred = pred.prev;} while (pred.waitStatus > 0);pred.next = node;} else {compareAndSetWaitStatus(pred, ws, Node.SIGNAL);// 将头节点的waitStatus设置成-1}return false;
}private final boolean parkAndCheckInterrupt() {LockSupport.park(this);return Thread.interrupted();
}

七:非公平锁解锁的具体流程

线程A就先去获取AQS的state,并对应减去1个,并设置当前占有线程为null,然后找到头节点去调用unparkSuccessor(head),他将头节点的状态从-1设置为0,然后唤醒线程B;

在这里插入图片描述
在这里插入图片描述

// 执行ReentrantLock.unlock()
public void unlock() {sync.release(1);
}// AQS.release()
public final boolean release(int arg) {if (tryRelease(arg)) {Node h = head;if (h != null && h.waitStatus != 0)unparkSuccessor(h);return true;}return false;
}// 执行ReentrantLock.tryRelease()
protected final boolean tryRelease(int releases) {int c = getState() - releases;if (Thread.currentThread() != getExclusiveOwnerThread())throw new IllegalMonitorStateException();boolean free = false;if (c == 0) {free = true;setExclusiveOwnerThread(null);}setState(c);return free;}private void unparkSuccessor(Node node) {int ws = node.waitStatus;// 头节点是-1if (ws < 0)compareAndSetWaitStatus(node, ws, 0);// 头节点设置为0Node s = node.next;// 线程Bif (s == null || s.waitStatus > 0) {s = null;for (Node t = tail; t != null && t != node; t = t.prev)if (t.waitStatus <= 0)s = t;}if (s != null) LockSupport.unpark(s.thread);//唤醒线程B
}

线程B还锁在parkAndCheckInterrupt()方法中,解锁后开始第三次循环,第三次循环发现前置节点是头,且可以占用锁,因此线程B获取到锁并进入第一个if;然后重新设置头节点,将头指向线程B,将原头节点剔除队列,然后将线程B设置成头节点。

final boolean acquireQueued(final Node node, int arg) {boolean failed = true;try {boolean interrupted = false;for (;;) {final Node p = node.predecessor();//获取节点的前置节点,线程B获取到的是头节点if (p == head && tryAcquire(arg)) {//目前锁无占用,进入此处setHead(node); // 重新设置头节点p.next = null; // help GCfailed = false;return interrupted; // 被改为true}if (shouldParkAfterFailedAcquire(p, node) &&parkAndCheckInterrupt())// 线程B从这里唤醒interrupted = true;}} finally {if (failed)cancelAcquire(node);}
}// 修改头节点          
private void setHead(Node node) {head = node;node.thread = null;node.prev = null;
}

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.hqwc.cn/news/156952.html

如若内容造成侵权/违法违规/事实不符,请联系编程知识网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

QT5交叉编译保姆级教程(arm64、mips64)

什么是交叉编译&#xff1f; 简单说&#xff0c;就是在当前系统平台上&#xff0c;开发编译运行于其它平台的程序。 比如本文硬件环境是x86平台&#xff0c;但是编译出来的程序是在arm64架构、mips64等架构上运行 本文使用的操作系统&#xff1a;统信UOS家庭版22.0 一、安装…

由QTableView/QTableWidget显示进度条和按钮,理解qt代理delegate用法

背景&#xff1a; 我的最初应用场景&#xff0c;就是要在表格上用进度条显示数据&#xff0c;以及放一个按钮。 qt-creator中有自带的delegate示例可以参考&#xff0c;但终归自己动手还是需要理解细节&#xff0c;否则不能随心所欲。 自认没那个天赋&#xff0c;于是记录下…

8. 一文快速学懂常用工具——Linux命令(上)

本章讲解知识点 引言 指令学习 本专栏适合于软件开发刚入职的学生或人士&#xff0c;有一定的编程基础&#xff0c;帮助大家快速掌握工作中必会的工具和指令。本专栏针对面试题答案进行了优化&#xff0c;尽量做到好记、言简意赅。如专栏内容有错漏&#xff0c;欢迎在评论区指…

瑞数专题五

今日文案&#xff1a;焦虑&#xff0c;想象力过度发酵的产物。 网址&#xff1a;https://www.iyiou.com/ 专题五主要是分享瑞数6代。6代很少见&#xff0c;所以找理想哥要的&#xff0c;感谢感谢。 关于瑞数作者之前已经分享过4篇文章&#xff0c;全都收录在瑞数专栏中了&am…

【计算机网络】浏览器的通信能力

1. 用户代理 浏览器可以代替用户完成http请求&#xff0c;代替用户解析响应结果&#xff0c;所以我们称之为用户代理 user agent。 浏览器两大核心能力&#xff1a; 自动发送请求的能力自动解析响应的能力 1.1 自动发送请求的能力 用户在地址栏输入了一个url地址&#xff0…

HarmonyOS数据管理与应用数据持久化(一)

一. 数据管理概述 功能介绍 数据管理为开发者提供数据存储、数据管理能力&#xff0c;比如联系人应用数据可以保存到数据库中&#xff0c;提供数据库的安全、可靠等管理机制。 数据存储&#xff1a;提供通用数据持久化能力&#xff0c;根据数据特点&#xff0c;分为用户首选项、…

逻辑分析仪与示波器选择

一、简介 逻辑分析仪是利用时钟从测试设备上采集和显示数字信号的仪器&#xff0c;最主要的作用在于时序判定。逻辑分析仪与示波器不同&#xff0c;它不能显示连续的模拟量波形&#xff0c;而只显示高低两种电平状态&#xff08;逻辑1和0&#xff09;。在设置了参考电压后&…

css中flexbox和grid的区别

css中flexbox和grid的区别 我们是不是被那些不会按预期排列的元素所影响&#xff1f;这篇文章我们将深入探讨css中flexbox和grid的布局。通过了解他们的主要差异&#xff0c;我们会发现这些布局是如何改变我们网站的风格。 理解CSS布局 css布局是网页设计的一个重要方面&…

【广州华锐互动】VR特警作战模拟演练系统

在科技发展的驱动下&#xff0c;各行各业都在寻找新的方式来提升效率和培训质量。其中&#xff0c;虚拟现实&#xff08;VR&#xff09;技术在各个领域都有广泛的应用&#xff0c;包括警察培训。VR特警作战模拟演练系统由VR公司广州华锐互动开发&#xff0c;它使用虚拟现实环境…

高效文件整理:按数量划分自动建立文件夹,轻松管理海量文件

在日常生活和工作中&#xff0c;我们经常需要处理大量的文件。然而&#xff0c;如何高效地整理这些文件却是一个棘手的问题。有时候&#xff0c;我们可能需要按照特定的规则来建立文件夹&#xff0c;以便更高效地整理文件。例如&#xff0c;您可以按照日期、时间或者特定的标签…

基于【逻辑回归】的评分卡模型金融借贷风控项目实战

背景知识&#xff1a; 在银行借贷过程中&#xff0c;评分卡是一种以分数形式来衡量一个客户的信用风险大小的手段。今天我们来复现一个评分A卡的模型。完整的模型开发所需流程包括&#xff1a;获取数据&#xff0c;数据清洗和特征工程&#xff0c;模型开发&#xff0c…

React中的状态管理

目录 前言 1. React中的状态管理 1.1 本地状态管理 1.2 全局状态管理 Redux React Context 2. React状态管理的优势 总结 前言 当谈到前端开发中的状态管理时&#xff0c;React是一个备受推崇的选择。React的状态管理机制被广泛应用于构建大型、复杂的应用程序&#xf…