LockSupport 的 park 和 unpark 以及线程中断对 park 的影响

park()

Thread t1 = new Thread(() -> {System.out.println("t1 park");LockSupport.park(); // 没有许可，线程将会被阻塞
}, "t1");t1.start();TimeUnit.MILLISECONDS.sleep(500); // 确保 t1 执行

unpark()

如果当前线程 thisThread 调用 LockSupport.park() 被阻塞，那么调用 LockSupport.unpark(thisThread) 将解除其阻塞; 如果线程没有被阻塞而调用了 LockSupport.unpark(thisThread)，则保证它下一次调用 LockSupport.park() 不会阻塞，但许可只能拥有一个

Thread t1 = new Thread(() -> {System.out.println("t1 unpark");LockSupport.unpark(Thread.currentThread()); // t1先获取许可System.out.println("t1 park");LockSupport.park(); // 拥有许可，线程将不会被阻塞，然后会释放许可
}, "t1");t1.start();TimeUnit.MILLISECONDS.sleep(500);

Thread t1 = new Thread(() -> {System.out.println("t1 unpark");LockSupport.unpark(Thread.currentThread()); // t1先获取许可System.out.println("t1 park");LockSupport.park(); // 拥有许可，线程将不会被阻塞，然后会释放许可System.out.println("t1 再次 park 阻塞");LockSupport.park(Thread.currentThread()); // 线程将会被阻塞
}, "t1");t1.start();TimeUnit.MILLISECONDS.sleep(500);

Thread t1 = new Thread(() -> {System.out.println("t1 unpark1");LockSupport.unpark(Thread.currentThread()); // t1获取 1 次许可System.out.println("t1 unpark2");LockSupport.unpark(Thread.currentThread()); // t1获取 2 次许可System.out.println("t1 unpark3");LockSupport.unpark(Thread.currentThread()); // t1获取 3 次许可System.out.println("t1 park");LockSupport.park(); // 拥有许可，线程将不会被阻塞，然后会释放许可System.out.println("t1 再次 park");LockSupport.park(Thread.currentThread()); // 线程将会被阻塞，许可只能用一次
}, "t1");t1.start();TimeUnit.MILLISECONDS.sleep(500);

`中断状态为 true 线程不会 park`

中断状态为 true 时，不会被 park，无论调用几次

// 中断对 park 的影响Thread t1 = new Thread(() -> {System.out.println("interrupt t1");Thread.currentThread().interrupt();System.out.println(Thread.currentThread().isInterrupted()); // trueSystem.out.println("park t1");LockSupport.park(); // 中断标记为true，线程将不会被阻塞System.out.println("t1 没有被 park");System.out.println("park t1");LockSupport.park(); // 线程还是不会阻塞System.out.println("t1 还是没有被 park");}, "t1");t1.start();TimeUnit.MILLISECONDS.sleep(500); // 确保 t1 执行

中断后调用 Thread.interrupted() 清除中断状态

Thread t1 = new Thread(() -> {System.out.println("interrupt t1");Thread.currentThread().interrupt();System.out.println(Thread.currentThread().isInterrupted()); // trueSystem.out.println(Thread.interrupted()); // trueSystem.out.println(Thread.currentThread().isInterrupted()); // falseSystem.out.println("park t1");LockSupport.park(); // 线程不阻塞System.out.println("第一次 park t1 没有阻塞");System.out.println("t1 再次 park 阻塞");LockSupport.park(); // 线程阻塞System.out.println("第二次 park t1 阻塞");}, "t1");t1.start();TimeUnit.MILLISECONDS.sleep(500); // 确保 t1 执行

可以看到，清除中断状态后，第一次 park 还是不起作用的，第二次 park 线程被阻塞了

不阻塞线程直接调用 Thread.interrupted()，第一次调用 park 就会阻塞

Thread t1 = new Thread(() -> {System.out.println(Thread.interrupted()); // falseSystem.out.println(Thread.currentThread().isInterrupted()); // falseSystem.out.println("park t1");LockSupport.park(); // 线程阻塞System.out.println("第一次 park t1 阻塞");}, "t1");t1.start();TimeUnit.MILLISECONDS.sleep(500); // 确保 t1 执行

因此线程中断并清除中断状态后，第二次调用 park 会被阻塞

但是还有一种情况：先 park，然后在外部（主线程）中断，中断了 park 后，中断标记还是 true，但是此时清除中断状态后的第一次 park 就会阻塞

Thread t1 = new Thread(() -> {System.out.println(Thread.currentThread().isInterrupted()); // falseLockSupport.park();System.out.println(Thread.currentThread().isInterrupted()); // trueSystem.out.println(Thread.interrupted()); // trueSystem.out.println(Thread.currentThread().isInterrupted()); // falseSystem.out.println("park t1");LockSupport.park(); // 线程阻塞}, "t1");t1.start();TimeUnit.MILLISECONDS.sleep(2000);t1.interrupt();

出现这两种情况不同的原因：
unpark() 将 _counter 置为 1，然后判断之前 _counter 是否为 0，如果为 0 则唤醒线程


void Parker::unpark() {//定义两个变量，staus用于判断是否获取锁
int s, status ;
//获取锁
status = pthread_mutex_lock(_mutex);
//判断是否成功
assert (status == 0, "invariant") ;
//存储原先变量_counter
s = _counter;
//把_counter设为1
_counter = 1;
if (s < 1) {// thread might be parkedif (_cur_index != -1) {// thread is definitely parkedif (WorkAroundNPTLTimedWaitHang) {status = pthread_cond_signal (&_cond[_cur_index]);assert (status == 0, "invariant");status = pthread_mutex_unlock(_mutex);assert (status == 0, "invariant");} else {status = pthread_mutex_unlock(_mutex);assert (status == 0, "invariant");status = pthread_cond_signal (&_cond[_cur_index]);assert (status == 0, "invariant");}} else {//释放锁pthread_mutex_unlock(_mutex);assert (status == 0, "invariant") ;}
} else {//释放锁pthread_mutex_unlock(_mutex);assert (status == 0, "invariant") ;
}
}

park() 首先会检查 _counter是否 > 0，如果 > 0，直接返回；还会检查中断标志位是否为 true，如果为 true 也会返回

  void Parker::park(bool isAbsolute, jlong time) {// Ideally we'd do something useful while spinning, such// as calling unpackTime().// Optional fast-path check:// Return immediately if a permit is available.// We depend on Atomic::xchg() having full barrier semantics// since we are doing a lock-free update to _counter.// 检查许可即 _counter 是否 > 0，> 0 直接 return，并原子性地把 _counter 改为 0if (Atomic::xchg(0, &_counter) > 0) return;  Thread* thread = Thread::current();assert(thread->is_Java_thread(), "Must be JavaThread");JavaThread *jt = (JavaThread *)thread;// Optional optimization -- avoid state transitions if there's an interrupt pending.// Check interrupt before trying to wait// 检查中断标志 如果 true 也返回if (Thread::is_interrupted(thread, false)) {  return;}

而 interrupt() 不仅会将中断标记设为 true，还会将 _counter 置为 1，下面是 interrupt 的 c++ 源码

void os::interrupt(Thread* thread) {assert(Thread::current() == thread || Threads_lock->owned_by_self(),"possibility of dangling Thread pointer");OSThread* osthread = thread->osthread();if (!osthread->interrupted()) {osthread->set_interrupted(true);// More than one thread can get here with the same value of osthread,// resulting in multiple notifications.  We do, however, want the store// to interrupted() to be visible to other threads before we execute unpark().OrderAccess::fence();ParkEvent * const slp = thread->_SleepEvent ;if (slp != NULL) slp->unpark() ;}// For JSR166. Unpark even if interrupt status already was setif (thread->is_Java_thread())((JavaThread*)thread)->parker()->unpark(); // 调用 unpark()ParkEvent * ev = thread->_ParkEvent ;if (ev != NULL) ev->unpark() ;}

而 Thread.interrupted() 虽然会清除中断标记，但并不会将 _counter 置为 0

public static boolean interrupted() {return currentThread().isInterrupted(true);
}

bool os::is_interrupted(Thread* thread, bool clear_interrupted) {assert(Thread::current() == thread || Threads_lock->owned_by_self(),"possibility of dangling Thread pointer");OSThread* osthread = thread->osthread();bool interrupted = osthread->interrupted();if (interrupted && clear_interrupted) {osthread->set_interrupted(false); // 清除中断标记// consider thread->_SleepEvent->reset() ... optional optimization}return interrupted;
}

因此:
第一种情况：调用 interrupted 后虽然清除中断标记，但并不会将 _counter 置为 0，所以第一次调用 park 时检查 _counter 还是 1，不会阻塞

第二种情况：

首先 park 阻塞，此时 _counter 是为 0（因为没调用 unpark，也没调用 interrupt呢）
但是之后调用 interrupt 将中断标记置为 true，_counter 又会置为 1，然后 park 被中断，此时 _counter 肯定会变为 0 了（这时相当于调用了 unpark，所以阻塞被唤醒，但是关于 unpark 是如何解除 park 的还不太清除，我猜可能是在 park 过程中会一直检查 _counter 的值，一旦发现是 1 就立即改为 0 并终止 park）
调用 Thread.interrupted() 清除了中断状态后，_counter 为 0 ，中断标记也为 true 了，所以再调用 park 会阻塞

更新
终于在知乎一个大佬的文章里找到了唤醒后将 _counter 改为 0 的代码了，具体可以看原文（参考文献[1]），由于我也看不懂 c++ 代码，大佬说啥就是啥吧

参考文献

[1] 令人困惑的LockSupport的park()和unpark()