jvm源码分析之yield和sleep

最新推荐文章于 2023-10-08 16:52:08 发布

zhifeng687

最新推荐文章于 2023-10-08 16:52:08 发布

阅读量1.3k

点赞数

分类专栏： java高并发实践

java高并发实践专栏收录该内容

41 篇文章 13 订阅

订阅专栏

转载自：Java线程源码解析之yield和sleep

概述
由于Thread的yield和sleep有一定的相似性，因此放在一起进行分析。yield会释放CPU资源，让优先级更高（至少是相同）的线程获得执行机会；sleep当传入参数为0时，和yield相同；当传入参数大于0时，也是释放CPU资源，当可以让其它任何优先级的线程获得执行机会；
假设当前进程只有main线程，当调用yield之后，main线程会继续运行，因为没有比它优先级更高的线程；而调用sleep之后，mian线程会进入TIMED_WAITING状态，不会继续运行；
yield
Thread.yield底层是通过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(); 
}

sched_yield()的man手册描述如下：

DESCRIPTION
sched_yield() causes the calling thread to relinquish the CPU. The thread is moved to the end of the queue for its static priority and a new thread gets to run.

RETURN VALUE
On success, sched_yield() returns 0. On error, -1 is returned, and errno is set appropriately.

ERRORS

In the Linux implementation, sched_yield() always succeeds.

翻译一下，sched_yield()会让出当前线程的CPU占有权，然后把线程放到静态优先队列的尾端，然后一个新的线程会占用CPU。

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 ; 
}

park(jlong millis)源码如下：

http://hg.openjdk.java.net/jdk7u/jdk7u/hotspot/file/677234770800/src/os/linux/vm/os_linux.cpp

int os::PlatformEvent::park(jlong millis) {
  guarantee (_nParked == 0, "invariant") ;

  int v ;
  for (;;) {
      v = _Event ;
      if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ;
  }
  guarantee (v >= 0, "invariant") ;
  if (v != 0) return OS_OK ;

  // We do this the hard way, by blocking the thread.
  // Consider enforcing a minimum timeout value.
  struct timespec abst;
  compute_abstime(&abst, millis);

  int ret = OS_TIMEOUT;
  int status = pthread_mutex_lock(_mutex);
  assert_status(status == 0, status, "mutex_lock");
  guarantee (_nParked == 0, "invariant") ;
  ++_nParked ;

  // Object.wait(timo) will return because of
  // (a) notification
  // (b) timeout
  // (c) thread.interrupt
  //
  // Thread.interrupt and object.notify{All} both call Event::set.
  // That is, we treat thread.interrupt as a special case of notification.
  // The underlying Solaris implementation, cond_timedwait, admits
  // spurious/premature wakeups, but the JLS/JVM spec prevents the
  // JVM from making those visible to Java code.  As such, we must
  // filter out spurious wakeups.  We assume all ETIME returns are valid.
  //
  // TODO: properly differentiate simultaneous notify+interrupt.
  // In that case, we should propagate the notify to another waiter.

  while (_Event < 0) {
    status = os::Linux::safe_cond_timedwait(_cond, _mutex, &abst);
    if (status != 0 && WorkAroundNPTLTimedWaitHang) {
      pthread_cond_destroy (_cond);
      pthread_cond_init (_cond, os::Linux::condAttr()) ;
    }
    assert_status(status == 0 || status == EINTR ||
                  status == ETIME || status == ETIMEDOUT,
                  status, "cond_timedwait");
    if (!FilterSpuriousWakeups) break ;                 // previous semantics
    if (status == ETIME || status == ETIMEDOUT) break ;
    // We consume and ignore EINTR and spurious wakeups.
  }
  --_nParked ;
  if (_Event >= 0) {
     ret = OS_OK;
  }
  _Event = 0 ;
  status = pthread_mutex_unlock(_mutex);
  assert_status(status == 0, status, "mutex_unlock");
  assert (_nParked == 0, "invariant") ;
  // Paranoia to ensure our locked and lock-free paths interact
  // correctly with each other.
  OrderAccess::fence();
  return ret;
}

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

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

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

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

Thread.yield

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

上图可以看到sched_yield的系统调用

Thread.sleep(nonzero)


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

在其中并没有看到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

关于两者之间的区别，请查看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(); 
}

参考资料

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

zhifeng687

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
jvm源码分析之yield和sleep

转载自：Java线程源码解析之yield和sleep概述由于Thread的yield和sleep有一定的相似性，因此放在一起进行分析。yield会释放CPU资源，让优先级更高（至少是相同）的线程获得执行机会；sleep当传入参数为0时，和yield相同；当传入参数大于0时，也是释放CPU资源，当可以让其它任何优先级的线程获得执行机会；假设当前进程只有main线程，当调用yield之后...
复制链接

扫一扫

专栏目录