@Test
    public void testPark() throws InterruptedException {
        Object parkObject = "I am parkObject";
        Thread t1 = new Thread(() -> {
            System.out.println("t1调用park");
            LockSupport.park(parkObject);
            System.out.println("t1被唤醒了");
        });

        t1.start();
        Thread.sleep(1000);
        Thread t2 = new Thread(() -> {
            System.out.println( LockSupport.getBlocker(t1));
            System.out.println("t2调用unpark");
            LockSupport.unpark(t1);
        });
        t2.start();
    }

/**
  Additionally, {@code park} will return if the caller's
  thread was interrupted, and timeout versions are supported. The
  {@code park} method may also return at any other time, for "no
  reason", so in general must be invoked within a loop that rechecks
  conditions upon return.
**/

@Test
    public void testInterruptAndPark() throws InterruptedException {
        Thread thread = new Thread(() -> {
            System.out.println("自己中断");
            Thread.currentThread().interrupt();

            System.out.println("打印线程中断状态：" + Thread.currentThread().isInterrupted());

            System.out.println("开始park");
            long st = System.currentTimeMillis();
            LockSupport.park();
            System.out.println("park结束,持续时间:" + (System.currentTimeMillis() - st));

            st = System.currentTimeMillis();
            LockSupport.park();
            System.out.println("park结束,持续时间:" + (System.currentTimeMillis() - st));
        });
        thread.start();
        Thread.sleep(100000);
    }

// thread.hpp
class Thread {
  // OS data associated with the thread
  OSThread* _osthread;  // Platform-specific thread information
  ParkEvent * _ParkEvent;    // for synchronized(), wait
  ParkEvent * _SleepEvent;   // for Thread.sleep
  // JSR166 per-thread parker
  Parker*    _parker; // for LockSupport::park
  //...
};
class JavaThread: public Thread {
  // 指向Java Thread实例, oop是HotSpot里指向一个Java level的实例, 一个gc对象.
  oop            _threadObj; // The Java level thread ,
  JavaFrameAnchor _anchor;   // Encapsulation of current java frame and it state
  CompiledMethod*   _deopt_nmethod; // CompiledMethod that is currently being deoptimized
  //
  volatile JavaThreadState _thread_state;
  //...
};

// src/hotspot/os/posix/os_posix.cpp
//isAbsolute 表示后面的时间是绝对时间还是相对时间
void Parker::park(bool isAbsolute, jlong time) {
  // 设置_counter为0，并且判断原值
  //  如果别的线程已经unpark了我.  
  //  这里没有使用锁机制，需要Atomic::xchg和barrier保证lock-free代码的正确.
  // We depend on Atomic::xchg() having full barrier semantics
  // since we are doing a lock-free update to _counter.
  if (Atomic::xchg(0, &_counter) > 0) return;

  Thread* thread = Thread::current();
  assert(thread->is_Java_thread(), "Must be JavaThread");
  JavaThread *jt = (JavaThread *)thread;

    // 如果线程被中断，直接返回
  if (Thread::is_interrupted(thread, false)) {
    return;
  }

  // safepoint region相关, 我对细节不详.
  // safepoint region大致的了解, 见RednaxelaFX的回答https://www.zhihu.com/question/29268019
  ThreadBlockInVM tbivm(jt);
  // 再次判断线程是否被中断，如果没有被中断，尝试获得互斥锁，如果获取失败，直接返回
  // 如果别的线程正在unpark我, 而持有了mutex, 我先返回了,没有必要在_mutex上等
  if (Thread::is_interrupted(thread, false) || pthread_mutex_trylock(_mutex) != 0) {
    return;
  }
  // 如果别的线程已经unblock了我, no wait needed
  // 已经拿到了mutex, 所以不需要和前面一样Atomic::xchg了.因为已经拿到了锁
  int status;
  if (_counter > 0)  {
    _counter = 0;
    status = pthread_mutex_unlock(_mutex);
    OrderAccess::fence();
    return;
  }
  // 记录线程的状态
  OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);
  jt->set_suspend_equivalent();
  // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()
  // 这一坨, 就是block自己这个线程了.(Java层当前执行的线程)
  if (time == 0) {
    _cur_index = REL_INDEX; // arbitrary choice when not timed
    status = pthread_cond_wait(&_cond[_cur_index], _mutex);
  } else {
    _cur_index = isAbsolute ? ABS_INDEX : REL_INDEX;
    status = pthread_cond_timedwait(&_cond[_cur_index], _mutex, &absTime);
  }
  _cur_index = -1;
  // 已经从block住状态中恢复返回了, 把_counter设0.
  _counter = 0;
  status = pthread_mutex_unlock(_mutex);
  // 要保证多线程的正确性要十二分小心
  // 这里的memory fence 是一个lock addl 指令, 加上compiler_barrier
  // 保证_counter = 0 是对调用unlock线程是可见的.
  // Paranoia to ensure our locked and lock-free paths interact
  // correctly with each other and Java-level accesses.
  OrderAccess::fence();
  // 已经醒过来, 但如果有别人在suspend我,那么继续suspend自己.
  // If externally suspended while waiting, re-suspend
  if (jt->handle_special_suspend_equivalent_condition()) {
    jt->java_suspend_self();
  }
}

// src/hotspot/os/posix/os_linux.cpp
void Parker::unpark() {
  int status = pthread_mutex_lock(_mutex);
  assert_status(status == 0, status, "invariant");
  const int s = _counter;
  _counter = 1;
  // must capture correct index before unlocking
  int index = _cur_index;
  status = pthread_mutex_unlock(_mutex);
  assert_status(status == 0, status, "invariant");

// s记录的是unpark之前的_counter数，如果s < 1，说明有可能该线程在等待状态，需要唤醒。
  if (s < 1 && index != -1) {
    // 发信号唤醒线程
    status = pthread_cond_signal(&_cond[index]);
    assert_status(status == 0, status, "invariant");
  }
}

//hotspot\src\os\linux\vm\os_linux.cpp
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 set
  if (thread->is_Java_thread())
    ((JavaThread*)thread)->parker()->unpark();
  ParkEvent * ev = thread->_ParkEvent ;
  if (ev != NULL) ev->unpark() ;
}