从Java到JVM到OS线程睡眠

时间 2019-12-06

标签 java jvm 线程睡眠栏目 Java 繁體版

原文原文链接

前言

Java 中有时须要将线程进入睡眠状态，这时通常咱们就会经过Thread.sleep使线程进入睡眠状态，接下去就看看执行该语句在 JVM 中作了什么。java

简单例子

如下是一个简单的例子，使主线程睡眠5秒钟。mysql

public class TestSleep {

	public static void main(String[] args) {
		try {
			Thread.sleep(5000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

}
复制代码

JVM 中的线程

在继续往 JVM 层看start0本地方法前，咱们先了解下 JVM 中的相关线程，这将有助于后面更好理解 Java 层线程与 JVM 中的线程对应关系。sql

在 JVM 中，也用 C++ 定义了一些 Thread 类，它们的继承结构以下，其中对于 Java 层线程到 JVM 层主要相关的有 Java 层的 java.lang.Thread、JavaThread 和 OSThread。安全

java.lang.Thread 属于 Java 层的线程对象，每一个 Java 层对象都会在 JVM 中使用 oop 来表示，因此它也会在 JVM 中产生一个 oop。
Thread 是 C++ 定义的线程基类，除了 OSThread 类，做为其余线程的基类，它包含了 OSThread 对象的指针。
JavaThread 是 C++ 定义的线程类，咱们在 Java 层建立的线程对象会使用 JavaThread 对象来表示，它包含了指向线程的 oop 的指针。
OSThread 是 C++ 定义的线程，它不与其余线程构成继承关系，它是 JVM 对不一样操做系统的线程的统一抽象，它维护了操做系统线程的句柄，用于获取操做系统的线程。

--Thread
	--JavaThread
		--CodeCacheSweeperThread
		--CompilerThread
		--JvmtiAgentThread
		--ServiceThread
	--NamedThread
		--ConcurrentGCThread
		--VMThread
		--WorkerThread
			--AbstractGangWorker
			--GCTaskThread
	--WatcherThread
--OSThread
复制代码

sleep方法

在 Thread 类中，sleep是一个静态且本地方法。bash

public static native void sleep(long millis) throws InterruptedException;
复制代码

Thread.c

Java 层声明的本地方法对应实如今 Thread.c 中，sleep是一个注册到 JVM 中的方法，它与 JVM 中的JVM_Sleep函数绑定了，因此实现逻辑在JVM_Sleep函数里。逻辑为：网络

JVMWrapper("JVM_Sleep")用于调试。
睡眠时间不能为负。
是否已经被中断了。
JavaThreadSleepState jtss(thread)用于修改线程状态并作一些统计，当睡眠结束后，会修改回线程状态，在 JavaThreadSleepState 的析构函数中修改。
睡眠时间若是为0，则根据ConvertSleepToYield作不一样处理，它表示是否将 sleep 操做转为 yield 操做。分别调用os::naked_yield和os::sleep处理，封装了不一样操做系统的调用实现，后面以 Windows 为例分别看相应实现。
经过thread->osthread()->get_state()获取 OSThread 对象，并将其状态设置为SLEEPING等到 sleep 结束后设置回原来的状态。
若是睡眠时间大于0，则作相似操做，不过它支持中断。
发送事件，结束。

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

  JavaThreadSleepState jtss(thread);

  HOTSPOT_THREAD_SLEEP_BEGIN(millis);

  EventThreadSleep event;

  if (millis == 0) {
    if (ConvertSleepToYield) {
      os::naked_yield();
    } else {
      ThreadState old_state = thread->osthread()->get_state();
      thread->osthread()->set_state(SLEEPING);
      os::sleep(thread, MinSleepInterval, false);
      thread->osthread()->set_state(old_state);
    }
  } else {
    ThreadState old_state = thread->osthread()->get_state();
    thread->osthread()->set_state(SLEEPING);
    if (os::sleep(thread, millis, true) == OS_INTRPT) {
      if (!HAS_PENDING_EXCEPTION) {
        if (event.should_commit()) {
          event.set_time(millis);
          event.commit();
        }
        HOTSPOT_THREAD_SLEEP_END(1);
        THROW_MSG(vmSymbols::java_lang_InterruptedException(), "sleep interrupted");
      }
    }
    thread->osthread()->set_state(old_state);
  }
  if (event.should_commit()) {
    event.set_time(millis);
    event.commit();
  }
  HOTSPOT_THREAD_SLEEP_END(0);
JVM_END
复制代码

os::naked_yield

naked_yield函数的实现很简单，就直接调用SwitchToThread系统函数。经过该函数可让系统查看是否有其余线程迫切须要CPU，将CPU让给其余线程，若是没有其余线程则当即返回。并发

void os::naked_yield() {
  SwitchToThread();
}
复制代码

os::sleep

获取最大限制大小limit。
若是超过 limit 则经过减法将其转成屡次递归调用sleep函数。
获取 OSThread 对象，而后经过 OSThreadWaitState 设置线程状态为等待，修改操做分别在构造函数和析构函数中实现。
根据是否支持中断作不一样实现，不须要中断则直接调用Sleep系统函数来实现。
若是要支持中断则接着作下面处理。
ThreadBlockInVM 主要是检查当前线程用不用进入 safepoint，后面再详细看。
接着主要到WaitForMultipleObjects系统函数，该函数能等待指定对象指定的毫秒数。若是等待过程当中对象没有接到任何信号，则超过指定毫秒数后返回WAIT_TIMEOUT，若是等待过程当中对象收到信号，则提早解除等待，此时返回的值为OS_INTRPT，即表示被中断了。

int os::sleep(Thread* thread, jlong ms, bool interruptable) {
  jlong limit = (jlong) MAXDWORD;

  while (ms > limit) {
    int res;
    if ((res = sleep(thread, limit, interruptable)) != OS_TIMEOUT) {
      return res;
    }
    ms -= limit;
  }

  assert(thread == Thread::current(), "thread consistency check");
  OSThread* osthread = thread->osthread();
  OSThreadWaitState osts(osthread, false /* not Object.wait() */);
  int result;
  if (interruptable) {
    assert(thread->is_Java_thread(), "must be java thread");
    JavaThread *jt = (JavaThread *) thread;
    ThreadBlockInVM tbivm(jt);

    jt->set_suspend_equivalent();
    HANDLE events[1];
    events[0] = osthread->interrupt_event();
    HighResolutionInterval *phri=NULL;
    if (!ForceTimeHighResolution) {
      phri = new HighResolutionInterval(ms);
    }
    if (WaitForMultipleObjects(1, events, FALSE, (DWORD)ms) == WAIT_TIMEOUT) {
      result = OS_TIMEOUT;
    } else {
      ResetEvent(osthread->interrupt_event());
      osthread->set_interrupted(false);
      result = OS_INTRPT;
    }
    delete phri; 
    jt->check_and_wait_while_suspended();
  } else {
    assert(!thread->is_Java_thread(), "must not be java thread");
    Sleep((long) ms);
    result = OS_TIMEOUT;
  }
  return result;
}
复制代码

ThreadBlockInVM

前面说到 ThreadBlockInVM 会检查当前线程用不用进入 safepoint，它主要的逻辑以下：app

首先设置 Java 线程状态，将状态加一，由_thread_in_vm = 6变为_thread_in_vm_trans = 7，从“运行vm自己代码”到“相应的过分状态”。
os::is_MP()用于判断计算机系统是否为多核系统，多核状况下须要作内存屏障处理，这是为了让每一个线程都能实时同步状态。
内存屏障有两种方式，一种是rderAccess::fence()，它的实现是直接经过CPU指令来实现，汇编指令为__asm__ volatile ("lock; addl $0,0(%%rsp)" : : : "cc", "memory");，这种方式代价比较大。而另一种为InterfaceSupport::serialize_memory，由 JVM 模拟实现，效率高一点。
调用SafepointSynchronize::block尝试在该安全点进行阻塞。
设置 Java 线程状态为_thread_blocked，即阻塞。

static inline void transition_and_fence(JavaThread *thread, JavaThreadState from, JavaThreadState to) {
    assert(thread->thread_state() == from, "coming from wrong thread state");
    assert((from & 1) == 0 && (to & 1) == 0, "odd numbers are transitions states");
    thread->set_thread_state((JavaThreadState)(from + 1));

    if (os::is_MP()) {
      if (UseMembar) {
        OrderAccess::fence();
      } else {
        // Must use this rather than serialization page in particular on Windows
        InterfaceSupport::serialize_memory(thread);
      }
    }

    if (SafepointSynchronize::do_call_back()) {
      SafepointSynchronize::block(thread);
    }
    thread->set_thread_state(to);

    CHECK_UNHANDLED_OOPS_ONLY(thread->clear_unhandled_oops();)
  }
复制代码

-------------推荐阅读------------机器学习

个人开源项目汇总(机器&深度学习、NLP、网络IO、AIML、mysql协议、chatbot)函数

跟我交流，向我提问：

欢迎关注：