Java线程源码解析之yield和sleep

概述

由于Thread的yield和sleep有一定的相似性，因此放在一起进行分析。yield会释放CPU资源，让优先级更高（至少是相同）的线程获得执行机会；sleep当传入参数为0时，和yield相同；当传入参数大于0时，也是释放CPU资源，当可以让其它任何优先级的线程获得执行机会；

假设当前进程只有main线程，当调用yield之后，main线程会继续运行，因为没有比它优先级更高的线程；而调用sleep之后，mian线程会进入TIMED_WAITING状态，不会继续运行；

yield

Thread.sleep底层是通过JVM_Yield方法实现的（见jvm.cpp）:

JVM_ENTRY(void, JVM_Yield(JNIEnv *env, jclass threadClass))  JVMWrapper("JVM_Yield");  //检查是否设置了DontYieldALot参数,默认为fasle  //如果设置为true,直接返回  if (os::dont_yield()) return; //如果ConvertYieldToSleep=true（默认为false）,调用os::sleep,否则调用os::yield  if (ConvertYieldToSleep) {    os::sleep(thread, MinSleepInterval, false);//sleep 1ms  } else {    os::yield();  }JVM_END

从上面知道，实际上调用的是os::yield:

//sched_yield是linux kernel提供的API,它会使调用线程放弃CPU使用权，加入到同等优先级队列的末尾；//如果调用线程是优先级最高的唯一线程，yield方法返回后，调用线程会继续运行；//因此可以知道，对于和调用线程相同或更高优先级的线程来说，yield方法会给予了它们一次运行的机会；void os::yield() {  sched_yield();}

sleep

Thread.sleep最终调用JVM_Sleep方法：

JVM_ENTRY(void, JVM_Sleep(JNIEnv* env, jclass threadClass, jlong millis))  JVMWrapper("JVM_Sleep");  if (millis < 0) {//参数校验    THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "timeout value is negative");  }  //如果线程已经中断，抛出中断异常,关于中断的实现，在另一篇文章中会讲解  if (Thread::is_interrupted (THREAD, true) && !HAS_PENDING_EXCEPTION) {    THROW_MSG(vmSymbols::java_lang_InterruptedException(), "sleep interrupted");  } //设置线程状态为SLEEPING  JavaThreadSleepState jtss(thread);  EventThreadSleep event;  if (millis == 0) {    //如果设置了ConvertSleepToYield(默认为true),和yield效果相同    if (ConvertSleepToYield) {      os::yield();    } else {//否则调用os::sleep方法      ThreadState old_state = thread->osthread()->get_state();      thread->osthread()->set_state(SLEEPING);      os::sleep(thread, MinSleepInterval, false);//sleep 1ms      thread->osthread()->set_state(old_state);    }  } else {//参数大于0   //保存初始状态，返回时恢复原状态    ThreadState old_state = thread->osthread()->get_state();    //osthread->thread status mapping:    // NEW->NEW    //RUNNABLE->RUNNABLE    //BLOCKED_ON_MONITOR_ENTER->BLOCKED    //IN_OBJECT_WAIT,PARKED->WAITING    //SLEEPING,IN_OBJECT_WAIT_TIMED,PARKED_TIMED->TIMED_WAITING    //TERMINATED->TERMINATED    thread->osthread()->set_state(SLEEPING);    //调用os::sleep方法，如果发生中断，抛出异常    if (os::sleep(thread, millis, true) == OS_INTRPT) {      if (!HAS_PENDING_EXCEPTION) {        if (event.should_commit()) {          event.set_time(millis);          event.commit();        }        THROW_MSG(vmSymbols::java_lang_InterruptedException(), "sleep interrupted");      }    }    thread->osthread()->set_state(old_state);//恢复osThread状态  }  if (event.should_commit()) {    event.set_time(millis);    event.commit();  }JVM_END

os::sleep的源码如下：

int os::sleep(Thread* thread, jlong millis, bool interruptible) {  assert(thread == Thread::current(),  "thread consistency check");  //线程有如下几个成员变量:  //ParkEvent * _ParkEvent ;          // for synchronized()  //ParkEvent * _SleepEvent ;        // for Thread.sleep  //ParkEvent * _MutexEvent ;      // for native internal Mutex/Monitor  //ParkEvent * _MuxEvent ;         // for low-level muxAcquire-muxRelease  ParkEvent * const slp = thread->_SleepEvent ;  slp->reset() ;  OrderAccess::fence() ;//如果millis>0,传入interruptible＝true,否则为false  if (interruptible) {    jlong prevtime = javaTimeNanos();    for (;;) {      if (os::is_interrupted(thread, true)) {//判断是否中断        return OS_INTRPT;      }      jlong newtime = javaTimeNanos();//获取当前时间      //如果linux不支持monotonic lock,有可能出现newtime<prevtime      if (newtime - prevtime < 0) {        assert(!Linux::supports_monotonic_clock(), "time moving backwards");      } else {        millis -= (newtime - prevtime) / NANOSECS_PER_MILLISEC;      }      if(millis <= 0) {        return OS_OK;      }      prevtime = newtime;      {        assert(thread->is_Java_thread(), "sanity check");        JavaThread *jt = (JavaThread *) thread;        ThreadBlockInVM tbivm(jt);        OSThreadWaitState osts(jt->osthread(), false );        jt->set_suspend_equivalent();        slp->park(millis);        jt->check_and_wait_while_suspended();      }    }  } else {//如果interruptible=false   //设置osthread的状态为CONDVAR_WAIT    OSThreadWaitState osts(thread->osthread(), false );    jlong prevtime = javaTimeNanos();    for (;;) {      jlong newtime = javaTimeNanos();      if (newtime - prevtime < 0) {        assert(!Linux::supports_monotonic_clock(), "time moving backwards");      } else {        millis -= (newtime - prevtime) / NANOSECS_PER_MILLISEC;      }      if(millis <= 0) break ;      prevtime = newtime;      slp->park(millis);//底层调用pthread_cond_timedwait实现    }    return OS_OK ;  }}

通过阅读源码知道，原来sleep是通过pthread_cond_timedwait实现的，那么为什么不通过linux的sleep实现呢？

• pthread_cond_timedwait既可以堵塞在某个条件变量上，也可以设置超时时间；
• sleep不能及时唤醒线程,最小精度为秒；

可以看出pthread_cond_timedwait使用灵活，而且时间精度更高；

＃ 例子
通过strace可以查看代码的系统调用情况，建立两个类，一个调用Thread.sleep(),一个调用Thread.yield(),查看其系统调用情况:

• Thread.sleep(0)

  Thread.sleep(0);System.out.println("hello");

  
  

  sleep0.png
  
  可以看到sched_yield的系统调用
• Thread.sleep(nonzero)

  Thread.sleep(1000);System.out.println("hello");

sleep2.png

在其中并没有看到pthread_cond_timedwait的调用，其实Java的线程有可两种实现方式：

1. LinuxThreads
2. NPTL(Native POSIX Thread Library)

   // NPTL or LinuxThreads?static bool is_LinuxThreads()               { return !_is_NPTL; }static bool is_NPTL()                       { return _is_NPTL;  }

   可以通过如下命令查看到底是使用哪种线程实现:

   getconf GNU_LIBPTHREAD_VERSION

nptl.png

关于两者之间的区别，请查看wiki。由于我的机器上采用的是2，因此无法看到ppthread_cond_timedwait的调用；
ppthread_cond_timedwait采用futex（Fast Userspace muTEXes）实现，因而可以看到对futex的调用；

关于JVM是如何决定采用哪种实现方式，可以查看如下方法(os_linux.cpp):

// detecting pthread libraryvoid os::Linux::libpthread_init() {  // Save glibc and pthread version strings. Note that _CS_GNU_LIBC_VERSION  // and _CS_GNU_LIBPTHREAD_VERSION are supported in glibc >= 2.3.2. Use a  // generic name for earlier versions.  // Define macros here so we can build HotSpot on old systems.# ifndef _CS_GNU_LIBC_VERSION# define _CS_GNU_LIBC_VERSION 2# endif# ifndef _CS_GNU_LIBPTHREAD_VERSION# define _CS_GNU_LIBPTHREAD_VERSION 3# endif  size_t n = confstr(_CS_GNU_LIBC_VERSION, NULL, 0);  if (n > 0) {     char *str = (char *)malloc(n, mtInternal);     confstr(_CS_GNU_LIBC_VERSION, str, n);     os::Linux::set_glibc_version(str);  } else {     // _CS_GNU_LIBC_VERSION is not supported, try gnu_get_libc_version()     static char _gnu_libc_version[32];     jio_snprintf(_gnu_libc_version, sizeof(_gnu_libc_version),              "glibc %s %s", gnu_get_libc_version(), gnu_get_libc_release());     os::Linux::set_glibc_version(_gnu_libc_version);  }  //系统函数confstr获取C库信息  n = confstr(_CS_GNU_LIBPTHREAD_VERSION, NULL, 0);  if (n > 0) {     char *str = (char *)malloc(n, mtInternal);     confstr(_CS_GNU_LIBPTHREAD_VERSION, str, n);     // Vanilla RH-9 (glibc 2.3.2) has a bug that confstr() always tells     // us "NPTL-0.29" even we are running with LinuxThreads. Check if this     // is the case. LinuxThreads has a hard limit on max number of threads.     // So sysconf(_SC_THREAD_THREADS_MAX) will return a positive value.     // On the other hand, NPTL does not have such a limit, sysconf()     // will return -1 and errno is not changed. Check if it is really NPTL.     if (strcmp(os::Linux::glibc_version(), "glibc 2.3.2") == 0 &&         strstr(str, "NPTL") &&         sysconf(_SC_THREAD_THREADS_MAX) > 0) {       free(str);       os::Linux::set_libpthread_version("linuxthreads");     } else {       os::Linux::set_libpthread_version(str);     }  } else {    // glibc before 2.3.2 only has LinuxThreads.    os::Linux::set_libpthread_version("linuxthreads");  }  if (strstr(libpthread_version(), "NPTL")) {     os::Linux::set_is_NPTL();  } else {     os::Linux::set_is_LinuxThreads();  }  // LinuxThreads have two flavors: floating-stack mode, which allows variable  // stack size; and fixed-stack mode. NPTL is always floating-stack.  if (os::Linux::is_NPTL() || os::Linux::supports_variable_stack_size()) {     os::Linux::set_is_floating_stack();  }}

• Thread.yield

  Thread.yield();System.out.println("hello");

Paste_Image.png

和Thread.sleep(0)相同；

参考资料

1. Linux 线程模型的比较：LinuxThreads 和 NPTL

作者：allanYan
链接：http://www.jianshu.com/p/0964124ae822
來源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。