Java 多线程学习(7)聊聊 LockSupport.park() 和 LockSupport.unpark()

转载请注明原创出处,谢谢!

HappyFeet的博客

最近在忙着找工作、找房子,事儿也挺多的,加上又换了个城市,也就没什么心思写博客了。如今工作已定,房子也租好了,是时候调整好自己的心态,开始写博客了。

说实话,这段时间面了不少公司,和很多面试官交流了许多,感触颇多,不过目前还没想好怎么写,我会尽快将这段时间辞职及面试的体会整理成一篇博客发表出来,还请大家耐心等待!

暂且把面试的事搁下,咱们今天来聊 LockSupport.park() 和 LockSupport.unpark() 的底层原理。

为什么会聊到这两个方法呢?原因是在阅读 AQS 的源码的时候发现这两个方法调用的次数非常多!所以在继续深入阅读 AQS 源码之前,先来熟悉一下 LockSupport.park() 和 LockSupport.unpark() 的底层实现,为后续 AQS 的学习打下基础。

一、LockSupport.park() 和 LockSupport.unpark()

1、那些你应该知道的基础知识

park 翻译成中文是 "停放" 的意思,在代码中的该方法含义是 "挂起" 当前线程

实际上,LockSupport 类中所提供的方法有许多,常用的有下面这几个:

  • park():无限期挂起当前线程
  • parkNanos(long nanos):挂起当前线程一段时间
  • parkUntil(long deadline):在 deadline 之前一直挂起当前线程
  • unpark(Thread thread):唤醒 thread 线程

其中 unpark 用于唤醒线程,其他三个均用于挂起线程。

挂起线程又分为无限期和有限期挂起,对应到线程的状态是 WAITING(无限期等待)和 TIMED_WAITING(限期等待)。

一个被无限期挂起的线程恢复的方式有三种:

  • 其他线程调用了 unpark 方法,参数为被挂起的线程

  • 其他线程中断了被挂起的线程

  • The call spuriously (that is, for no reason) returns.

    这里讲的是虚假唤醒,可以参考以下几篇资料:

    • Why does pthread_cond_wait have spurious wakeups?
    • Do spurious wakeups in Java actually happen?

    由于虚假唤醒的存在,在调用 park 时一般采用自旋的方式,伪代码如下:

    while (!canProceed()) { 
            ...
            LockSupport.park(this);
        }
    复制代码

而有限期挂起的除了上面三种之外,还有第四种方式:

  • 经过了挂起的时间段或者是达到了指定的 deadline

2、它们有何特点?

This class associates, with each thread that uses it, a permit.
复制代码

Java 文档
里说到了,每个线程都关联一个许可(permit)。

当许可可用时,调用 park 会立即返回,否则可能(虚假唤醒则不会被挂起)被挂起;如果许可不可用时,调用 unpark 会使得许可变成可用,而如果许可本身是可用时,调用 unpark 不会有任何影响。

可能直接看文字不是那么的一目了然,我们来看几个例子:

  • 例一:park 挂起线程,unpark 唤醒被挂起的线程

public static void exampleOne() {
    Thread thread = new Thread(() -> {
        while (flag) {

        }

        System.out.println("before first park");
        LockSupport.park();
        System.out.println("after first park");
        LockSupport.park();
        System.out.println("after second park");

    });

    thread.start();

    flag = false;

    sleep(20);

    System.out.println("before unpark.");
    LockSupport.unpark(thread);
}
复制代码

输出结果

before first park
before unpark
after first park
复制代码

分析

首先,许可初始是不可用的;所以在调用 park 后 thread 被挂起,后续主线程调用了 unpark 方法唤醒了被挂起的 thread,输出 after first park
,紧接着 thread 调用 park 继续被挂起。

  • 例二:unpark 效果不会被累积

private static void exampleTwo() {
    Thread thread = new Thread(() -> {
        while (flag) {

        }

        System.out.println("before first park");
        LockSupport.park();
        System.out.println("after first park");
        LockSupport.park();
        System.out.println("after second park");

    });

    thread.start();

    LockSupport.unpark(thread);
    LockSupport.unpark(thread);

    flag = false;
}
复制代码

输出结果

before first park
after first park
复制代码

分析

主线程先对 thread 执行两次 unpark 操作,然后 thread 再连续调用两次 park 方法,结果发现,第二个 park 会挂起 thread;这里主要体现了 unpark 效果不会被累积,当许可可用时,调用 unpark 方法不会产生任何效果。

  • 例三:中断对 park 的影响

private static void exampleThree() {
    Thread thread = new Thread(() -> {

        System.out.println("before first park");
        LockSupport.park();
        System.out.println("after first park");
        LockSupport.park();
        System.out.println("after second park");
        System.out.println("isInterrupted is " + Thread.interrupted());
        System.out.println("isInterrupted is " + Thread.interrupted());
        LockSupport.park();
        System.out.println("after third park");
    });

    thread.start();

    sleep(200);

    thread.interrupt();
}
复制代码

输出结果

before first park
after first park
after second park
isInterrupted is true
isInterrupted is false
复制代码

分析

thread 先后共调用了三次 park,前两次调用没啥区别,在第三次调用之前调用了两次 Thread.interrupted();从输出结果来看,发现前两次 park 并没有生效,只有第三次 park 将线程挂起了,Why?

我们先来看 Thread.interrupted() 的作用:**判断当前线程的中断状态,同时将中断状态清除。**实际上这里只需要调用一次 Thread.interrupted() 即可,调用了两次是为了查看线程中断状态的变化。

当线程的中断状态为 true 时,park 失去了效果,不会挂起线程;而当调用了 Thread.interrupted() 将中断状态清除之后,park 又恢复了效果。

所以这里可以得出的结论: 线程中断会使 park 失效

完整示例代码传送门

二、源码跟踪

重头戏来啦!上面讲到了 park 和 unpark 的几个方法,其实它们最终对应于 UNSAFE.park(boolean isAbsolute, long time) 和 UNSAFE.unpark(Object thread) 这两个 native 方法。

下面我们就去看看这两个 native 方法是如何实现的。

1、UNSAFE.park(boolean isAbsolute, long time)

(1) unsafe.cpp#Unsafe_Park
openjdk/hotspot/src/share/vm/prims/unsafe.cpp

UNSAFE_ENTRY(void, Unsafe_Park(JNIEnv *env, jobject unsafe, jboolean isAbsolute, jlong time))
  UnsafeWrapper("Unsafe_Park");
  EventThreadPark event;
#ifndef USDT2
  HS_DTRACE_PROBE3(hotspot, thread__park__begin, thread->parker(), (int) isAbsolute, time);
#else /* USDT2 */
   HOTSPOT_THREAD_PARK_BEGIN(
                             (uintptr_t) thread->parker(), (int) isAbsolute, time);
#endif /* USDT2 */
  JavaThreadParkedState jtps(thread, time != 0);
  thread->parker()->park(isAbsolute != 0, time);
#ifndef USDT2
  HS_DTRACE_PROBE1(hotspot, thread__park__end, thread->parker());
#else /* USDT2 */
  HOTSPOT_THREAD_PARK_END(
                          (uintptr_t) thread->parker());
#endif /* USDT2 */
  ...
UNSAFE_END
复制代码

点击查看源码

这里有几个分支判断,不过可以看出无论是哪个分支,最终都会走 park(bool isAbsolute, jlong time)
这个方法。

(2) os_linux.cpp#Parker::park
openjdk/hotspot/src/os/linux/vm/os_linux.cpp

void Parker::park(bool isAbsolute, jlong time) {
			...
  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;
  }

  // Next, demultiplex/decode time arguments
  timespec absTime;
  if (time < 0 || (isAbsolute && time == 0) ) { // don't wait at all
    return;
  }
  if (time > 0) {
    unpackTime(&absTime, isAbsolute, time);
  }
			...
  if (Thread::is_interrupted(thread, false) || pthread_mutex_trylock(_mutex) != 0) {
    return;
  }
  
  int status ;
  if (_counter > 0)  { // no wait needed
    _counter = 0;
    status = pthread_mutex_unlock(_mutex);
    assert (status == 0, "invariant") ;
    // Paranoia to ensure our locked and lock-free paths interact
    // correctly with each other and Java-level accesses.
    OrderAccess::fence();
    return;
  }

  assert(_cur_index == -1, "invariant");
  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 = os::Linux::safe_cond_timedwait (&_cond[_cur_index], _mutex, &absTime) ;
    if (status != 0 && WorkAroundNPTLTimedWaitHang) {
      pthread_cond_destroy (&_cond[_cur_index]) ;
      pthread_cond_init    (&_cond[_cur_index], isAbsolute ? NULL : os::Linux::condAttr());
    }
  }

  		...
  _counter = 0 ;
  status = pthread_mutex_unlock(_mutex) ;
  OrderAccess::fence();

  // If externally suspended while waiting, re-suspend
  if (jt->handle_special_suspend_equivalent_condition()) {
    jt->java_suspend_self();
  }
}
复制代码

点击查看源码

  • 首先通过 Atomic::xchg(0, &_counter) 方法将 _counter 置 0,如果原来的 _counter > 0,说明原来的许可是可用的,直接返回;

  • 如果当前线程的处于中断状态,直接返回;

Thread::is_interrupted(thread, false) 只会判断线程的中断状态,不会重置其中断状态;Thread.interrupted() 调用的是 Thread::is_interrupted(thread, true),判断线程的中断状态同时将其重置。

  • 如果 time < 0 或者 isAbsolute 为 true 且 time = 0,说明不需要挂起线程,直接返回;否则将 time 换算成 absTime,后续有限期等待会用到。
  • 再次判断 _counter 的值,如果大于 0,说明原来的许可是可用的,将其置 0,然后直接返回。这里应该是在Atomic::xchg 到获取的之间有 unpark 操作,使得 _counter 的值变为 1 了;
  • 判断如果 time == 0,调用 pthread_cond_wait 方法,进入无限期等待;否则,调用 os::Linux::safe_cond_timedwait 方法,这个方法最终调用的是 pthread_cond_timedwait,从而进入有限期等待。

关于 pthread_cond_wait 可以看一下这篇文章: pthread_cond_wait 详解

感觉和 Object.wait、Object.notify、Object.notifyAll 的机制很类似。

2、UNSAFE.unpark(Object thread)

(1) unsafe.cpp#Unsafe_Unpark
openjdk/hotspot/src/share/vm/prims/unsafe.cpp

UNSAFE_ENTRY(void, Unsafe_Unpark(JNIEnv *env, jobject unsafe, jobject jthread))
  UnsafeWrapper("Unsafe_Unpark");
  Parker* p = NULL;
  if (jthread != NULL) {
    oop java_thread = JNIHandles::resolve_non_null(jthread);
    if (java_thread != NULL) {
      jlong lp = java_lang_Thread::park_event(java_thread);
      if (lp != 0) {
        // This cast is OK even though the jlong might have been read
        // non-atomically on 32bit systems, since there, one word will
        // always be zero anyway and the value set is always the same
        p = (Parker*)addr_from_java(lp);
      } else {
        // Grab lock if apparently null or using older version of library
        MutexLocker mu(Threads_lock);
        java_thread = JNIHandles::resolve_non_null(jthread);
        if (java_thread != NULL) {
          JavaThread* thr = java_lang_Thread::thread(java_thread);
          if (thr != NULL) {
            p = thr->parker();
            if (p != NULL) { // Bind to Java thread for next time.
              java_lang_Thread::set_park_event(java_thread, addr_to_java(p));
            }
          }
        }
      }
    }
  }
  if (p != NULL) {
#ifndef USDT2
    HS_DTRACE_PROBE1(hotspot, thread__unpark, p);
#else /* USDT2 */
    HOTSPOT_THREAD_UNPARK(
                          (uintptr_t) p);
#endif /* USDT2 */
    p->unpark();
  }
UNSAFE_END
复制代码

点击查看源码

前面一大段代码是在给 Parker* p 赋值,最终调用的是 p 的 unpark 方法:p->unpark()。

(2) os_linux.cpp#Parker::unpark
openjdk/hotspot/src/os/linux/vm/os_linux.cpp

void Parker::unpark() {
  int s, status ;
  status = pthread_mutex_lock(_mutex);
  assert (status == 0, "invariant") ;
  s = _counter;
  _counter = 1;
  if (s < 1) {
    // thread might be parked
    if (_cur_index != -1) {
      // thread is definitely parked
      if (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") ;
  }
}
复制代码

点击查看源码

unpark 方法其实很简单,首先通过 pthread_mutex_lock 获取锁,然后将 _counter 置为 1,再判断当前是否有线程被挂起,如果有,则通过 pthread_cond_signal 唤醒被挂起的线程,然后释放锁。

三、结语

学习知识真是一环扣一环,学一个不会的知识点,很容易碰到新的不会的知识点,然后不断的接触新知识点,不断地学习新的内容;当你不断的学习,不断的把新知识点吃透,慢慢的又会发现其实很多知识点的思想又是相通的,学起来反而没那么费劲了。

就好比看到 pthread_cond_wait 的机制时,就会联想到 Object.wait,因为两者的实现有很多相像的地方,理解起来也就比较简单。

最后留一个问题,大家可以思考一下:LockSupport.park 和 Object.wait 两者有何区别?

参考资料:

(1) 由几个小例引发的对interrupt()、LockSupport.park()深入解析

(2) Class LockSupport

原文 

https://juejin.im/post/5e771bdd51882549575fb2fb

本站部分文章源于互联网,本着传播知识、有益学习和研究的目的进行的转载,为网友免费提供。如有著作权人或出版方提出异议,本站将立即删除。如果您对文章转载有任何疑问请告之我们,以便我们及时纠正。

PS:推荐一个微信公众号: askHarries 或者qq群:474807195,里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多

转载请注明原文出处:Harries Blog™ » Java 多线程学习(7)聊聊 LockSupport.park() 和 LockSupport.unpark()

赞 (0)
分享到:更多 ()

评论 0

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址