概述
由於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_ENDos::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的線程有可兩種實現方式：
- LinuxThreads
- 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 library
void 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)相同；
參考資料
作者：allanYan
鏈接：http://www.jianshu.com/p/0964124ae822
來源：簡書
著作權歸作者所有。商業轉載請聯繫作者獲得授權，非商業轉載請註明出處。
