package cn.daheww.demo.juc.reentrylock;
import sun.misc.Unsafe;
import java.lang.reflect.Field;
import java.util.concurrent.locks.LockSupport;
/**
* @author daheww
* @date 2022/7/7
*/
public class MiniReentryLock implements Lock {
/**
* 锁的是什么 --> 资源 --> state
* 0 --> 未加锁
* >0 -> 加锁
*/
private volatile int state;
/**
* 独占模式
* 同一时刻只有一个线程可以持有锁，其它线程在未获取到锁的时候会被阻塞
*
* 当前独占锁的线程（占用锁的线程）
*/
private Thread exclusiveOwnerThread;
/**
* 需要有两个节点去维护阻塞队列
* Head 指向队列的头节点
* Tail 指向队列的尾节点
*
* 比较特殊：Head节点对应的线程就是当前占用锁的线程
*/
private Node head;
private Node tail;
/**
* 获取锁
* 假设当前锁被占用，则会阻塞调用者线程，直到它抢占到锁为止
*
* 模拟公平锁
* --> 先来后到
*
* lock的过程
* 情景1.线程进来后发现，当前state == 0 --> 直接去抢锁
* 情景2.线程进来后发现，当前state > 0 --> 将当前线程入队
*/
@Override
public void lock() {
// 第一次获取到锁时，将state设置为1
// 第n次重入时，将state设置为n
acquire(1);
}
@Override
public void unlock() {
release(1);
}
private void release(int arg) {
// 条件成立：说明线程已经完全释放锁了
if (tryRelease(arg)) {
// 阻塞队列里面，还有睡觉的线程，应该唤醒一个线程
// 首先需要知道有没有等待的node --> head.next == null
Node head = this.head;
if (head.nx != null) {
// 公平锁，唤醒head.nx节点
unparkSuccessor(head);
}
}
}
private void unparkSuccessor(Node node) {
Node s = node.nx;
if (s != null && s.thread != null) {
LockSupport.unpark(s.thread);
}
}
/**
* 完全释放锁成功则返回true
*/
private boolean tryRelease(int arg) {
int c = getState() - arg;
if (getExclusiveOwnerThread() != Thread.currentThread()) {
throw new RuntimeException("must get lock first");
}
// 如果执行到这里，不存在并发，只会有一个线程会来到这里
// 条件成立，则说明当前线程持有的lock锁已经完全释放了
if (c == 0) {
this.exclusiveOwnerThread = null;
this.state = c;
return true;
} else {
this.state = c;
return false;
}
}
/**
* 竞争资源
* 1.尝试获取锁。成功则占用锁，且返回
* 2.抢占锁失败，阻塞当前线程
* @param arg
*/
private void acquire(int arg) {
if (!tryAcquire(arg)) {
// 抢锁失败
// step1.将当前线程封装成node，加入到阻塞队列中
Node node = addWaiter();
// step2.将当前线程park，使线程处于挂起状态
acquireQueued(node, arg);
}
// 抢锁成功
// 1.抢到了锁
// 2.重入了锁
}
/**
* 尝试抢锁失败，需要做的事：
* 1.需要将当前线程封装成node，加入到阻塞队列中
* 2.需要将当前线程park，使线程处于挂起状态
*
* 唤醒的流程：
* 1.检查当前node是否为head.next节点
* head.next是拥有抢占权限的线程，其它node都没有抢占的权限
* 2.抢占：
* 成功：
* 1.将当前node设置为node，将老的head出队，返回到业务层面
* 2.继续park等待被唤醒
*
* ----------------------------------------------
* 1.添加到阻塞队列的逻辑 addWaiter()
* 2.竞争资源的逻辑 acquireQueued()
*/
private void acquireQueued(Node node, int arg) {
// 当前线程已经放到queue中了
// 只有当前node成功获取到锁以后才会跳出自旋
for (; ; ) {
// 什么情况下，当前node被唤醒后可以尝试去获取锁呢？
// 只有一种情况，当前node是head的后继节点，才有这个权限
// 不是就先来后到
Node pvNode = node.pv;
// 条件1：pvNode == head
// true --> 说明当前node拥有抢占权限
// queue中的第一个节点代表的是当前锁正在执行的线程 --> head指向的线程
// head后面的线程代表的是正在排队的线程 --> 所以只有head.nx节点拥有抢锁的权利
// 条件2：tryAcquire(arg)
// true --> 当前线程获取到了锁
//
if (pvNode == head && tryAcquire(arg)) {
// 进入到这里面说明当前线程竞争锁成功了
// 需要做的操作：
// 1.设置当前head为当前线程的node
// 2.协助原来的对象出队
setHead(node);
pvNode.nx = null;
// 因为获取到了锁，所以就return了
return;
}
// 当前不是head.nx节点，或者去尝试获取锁失败了，这个时候都需要去把当前线程park掉
System.out.println("线程：" + Thread.currentThread().getName() + " 挂起");
LockSupport.park();
// 直到某个线程做了当前线程的unPark操作，这个线程才会继续执行
/*
所以总结一下，lock的逻辑就是：
1.在没锁的情况下，如果有个线程调用了lock方法，它就会改变lock中的state值。此时state值就不会为0了。
那么其它线程调用lock方法时，会看到这个state不为0。
2.然后这个线程会被封装成一个node节点
3.然后会去尝试竞争一下锁，做一下最后的挽救工作，如果实在挽救不了，就park了
--> 线程就在这个lock的lock()方法里被阻塞了。就达到了锁的效果
--> 所有调用这个锁对象lock的方法只能有一个线程能继续执行，然后其它线程会被阻塞，直到这个线程做了unlock操作
*/
System.out.println("线程：" + Thread.currentThread().getName() + " 唤醒");
// 什么时候唤醒被park的线程？--> unlock()
}
}
/**
* 把当前线程入队
* 返回当前线程对应的node节点
*
* addWaiter执行完成后，保证当前线程已经入队成功
*/
private Node addWaiter() {
Node newNode = new Node(Thread.currentThread());
// 如何入队？
// Case1.当前node不是第一个入队的node，队列已经有等待的node了
// 1.找到newNode的pv节点
// 2.更新newNode.pvNode = pv节点
// 3.CAS更新tail为newNode
// 4.更新pv节点
Node pvNode = tail;
if (pvNode != null) {
newNode.pv = pvNode;
// 条件成立，说明当前线程成功入队
if (compareAndSetTail(pvNode, newNode)) {
pvNode.nx = newNode;
return newNode;
}
}
// 执行到这里的几种情况
// 1.tail == null队列是空
// 2.cas设置当前newNode为tail时失败了 --> 循环入队 --> 自旋
enq(newNode);
return newNode;
}
/**
* 自旋入队，只有成功之后才返回
* 1.tail == null 队列是空队列
* 2.cas设置当前newNode为tail时失败了
*/
private void enq(Node node) {
for (; ; ) {
// 第一种情况：队列是空队列
// --> 当前线程是第一个抢占锁的线程...
// 当前持有锁的线程，并没有设置过任何node，所以作为该线程的第一个后驱节点
// 需要给他擦屁股
// 给当前持有锁的线程补充一个node作为head节点
// head节点任何时候都代表当前占用锁的线程
if (tail == null) {
// 条件成立：说明当前线程给当前持有锁的线程补充head操作成功了
if (compareAndSetHead(new Node())) {
tail = head;
// 注意，并没有直接返回，而是会继续自旋
}
} else {
// 当前队列中已经有node了，说明这是一个追加node的过程
// 如何入队呢？
// 1.找到newNode的pv节点 --> 最新的tail节点
// 2.更新newNode.pvNode = pv节点
// 3.CAS更新tail为newNode
// 4.更新pv节点
Node pvNode = tail;
node.pv = pvNode;
// 条件成立，说明当前线程成功入队
if (compareAndSetTail(pvNode, node)) {
pvNode.nx = node;
return;
}
}
}
}
/**
* 尝试获取锁，不会去阻塞线程
* true --> 抢占成功
* false --> 抢占失败
*/
private boolean tryAcquire(int arg) {
if (state == 0) {
// 当前state为0
// 不能直接抢锁 --> 公平锁 --> 先来后到
// 条件一：!hasQueuedPredecessors() ---> 取反之后为true，表示当前线程前面没有等待着的线程
// 条件二：compareAndSetState(0, arg) -> 使用cas的原因：lock方法可能有多线程调用的情况
// true --> 当前线程抢锁成功
// (1) volatile --> state被volatile修饰了，所以其它线程能第一时间知道这个值不为0了 --> 缓存能够一致了
// (2) cas -------> state从0变为arg的操作用cas实现，用于保证只会有一个线程能够改变state的值（0->arg） --> 只会有一个线程能够执行接下来的操作 --> 锁
// 1.如果cas的变量不用volatile修饰就没有意义：
// 因为A线程改变了state的值，但是B线程并不知道
// （可见性，volatile会让B线程中的副本马上失效，然后获取最新的state的值，此时B线程工作空间中的state值就不为0了）
// 2.如果volatile的变量不用cas去改变它的值的话，也没有意义：
//· step1.A线程，B线程都拿到了state的副本信息，此时state值为0
// step2.A线程改变了state的值。B线程还在写，因为state的值改变了，所以B线程工作空间中的state值改变，然后B继续写。
// 所以所有判断出state值为0的线程都能写成功，并且能执行写成功后续的操作
// 所以要用cas+volatile去保证只会有一个线程能够写成功这个值
// Ps.可以看到，如果这些线程想写的值都是同一个值的话，多写了几次，但是结果和只写一次是一致的
// cas+volatile主要还是去控制写成功之后的操作只会被执行一次，这样就像一个锁一样了
if (!hasQueuedPredecessors() && compareAndSetState(0, arg)) {
// 抢锁成功
// 1.将exclusiveOwnerThread设置为当前线程
this.exclusiveOwnerThread = Thread.currentThread();
return true;
// 不会入队任何node，接返回true
// 接下来第一个竞争失败的线程会先去帮忙创建一个node，然后再执行后续的操作
}
// 当前线程前面有线程在等待 || 多个线程和当前线程一起在尝试获取这个锁，然后当前线程失败了 --> return false;
} else if (Thread.currentThread() == this.exclusiveOwnerThread) {
// 执行的时机：
// 1.当前锁被占用
// 2.当前线程即为持锁线程
// 这里面不存在并发。只有当前加锁的线程才有权限修改state
// 即使是同一个线程多次进入到这，设置state的值，那么它们都是使用的同一个工作空间
// 不存在不同工作空间下，这个值的不一样的情况（因为没有了缓存）
// 锁重入的流程
int c = getState();
c += arg;
// TODO 越界判断
this.state = c;
return true;
}
// 什么时候会返回false？
// 1.cas加锁失败
// 2.state大于0，且当前线程不是持锁线程
return false;
}
/**
* 当前线程前面是否有等待着的线程
* true --> 当前线程前面有等待着的线程
* false -> 当前线程前面没有其它等待着的线程
*
* 调用链
* lock --> acquire -> tryAcquire -> hasQueuedPredecessors(state值为0时，即当前lock为无主状态)
*
* 什么时候返回false？
* 1.当前队列是空
* 2.当前线程为head.next节点 --> head.next在任何时候都有权力去争取lock
*/
private boolean hasQueuedPredecessors() {
Node h = head;
Node t = tail;
Node s;
// 条件一：h != t
// true --> 当前队列已经有node了
// false -> h == t
// case1. h == t == null --> 还没初始化过queue
// case2. h == t == head
// 第一个获取锁失败的线程会为当前持有锁的线程补充创建一个head node
// 条件二：
// 前置条件：条件一成立
// 排除几种情况：
// 条件2.1：极端情况 --> 第一个获取锁失败的线程，会为持锁的线程补充创建head节点，然后在自旋入队
// step1.cas设置tail成功了
// step2.head.next = node
// 在这两步中间的时候，有线程来检查前面是否有等待的线程
// 这种情况应该返回true：已经有head.next节点了，其它线程来这的时候需要返回true
// 条件2.2：
// 前置条件：h.next不是null
// true --> 条件成立说明当前线程就是持有锁的线程
// false -> 说明当前线程就是h.next节点对应的线程，需要返回false。回头线程就会去竞争锁了
return h != t && ((s = h.nx) == null || s.thread != Thread.currentThread());
}
private static final Unsafe UNSAFE;
private static final long STATE_OFFSET;
private static final long HEAD_OFFSET;
private static final long TAIL_OFFSET;
static {
try {
Field f = Unsafe.class.getDeclaredField("theUnsafe");
f.setAccessible(true);
UNSAFE = (Unsafe) f.get(null);
STATE_OFFSET = UNSAFE.objectFieldOffset(MiniReentryLock.class.getDeclaredField("state"));
HEAD_OFFSET = UNSAFE.objectFieldOffset(MiniReentryLock.class.getDeclaredField("head"));
TAIL_OFFSET = UNSAFE.objectFieldOffset(MiniReentryLock.class.getDeclaredField("tail"));
} catch (Exception e) {
throw new Error(e);
}
}
private boolean compareAndSetHead(Node update) {
return UNSAFE.compareAndSwapObject(this, HEAD_OFFSET, null, update);
}
private boolean compareAndSetTail(Node expect, Node update) {
return UNSAFE.compareAndSwapObject(this, TAIL_OFFSET, expect, update);
}
private boolean compareAndSetState(int expect, int update) {
return UNSAFE.compareAndSwapInt(this, STATE_OFFSET, expect, update);
}
/**
* 阻塞的线程被封装成node节点，然后放进FIFO队列
*/
static final class Node {
/**
* 封装的线程本身
*/
Thread thread;
/**
* 前置节点引用
*/
Node pv;
/**
* 后置节点引用
*/
Node nx;
public Node(Thread thread) {
this.thread = thread;
}
public Node() {
}
}
public int getState() {
return state;
}
private void setHead(Node node) {
this.head = node;
// 当前线程已经是获取到锁的线程
node.thread = null;
node.pv = null;
}
public void setState(int state) {
this.state = state;
}
public Thread getExclusiveOwnerThread() {
return exclusiveOwnerThread;
}
public void setExclusiveOwnerThread(Thread exclusiveOwnerThread) {
this.exclusiveOwnerThread = exclusiveOwnerThread;
}
public Node getHead() {
return head;
}
public Node getTail() {
return tail;
}
public void setTail(Node tail) {
this.tail = tail;
}
}