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;
}