本文深入探讨虚拟机运行时的java线程启动、停止、睡眠与中断

JavaThread* java_lang_Thread::thread(oop java_thread) {
// 通过线程对象获取JavaThread（返回long值，强制类型转换为JavaThread*）
return (JavaThread*)java_thread->address_field(_eetop_offset);
}
class JavaThread: public Thread {
oop _threadObj;
// 通过JavaThread获取线程对象
oop threadObj() const { return _threadObj; }
...
};

// Thread.start()对应JVM_StartThread
JVM_ENTRY(void, JVM_StartThread(...))
...
// 虚拟机创建JavaThread，该类内部会创建操作系统线程，然后关联Java线程
native_thread = new JavaThread(&thread_entry, sz);
...
// 设置线程状态为RUNNABLE
Thread::start(native_thread);
JVM_END
// JVM_StartThread创建操作系统线程，执行thread_entry函数
static void thread_entry(JavaThread* thread, TRAPS) {
HandleMark hm(THREAD);
Handle obj(THREAD, thread->threadObj());
JavaValue result(T_VOID);
// Thread.start()调用java.lang.Thread类的run方法
JavaCalls::call_virtual(&result,obj, SystemDictionary::Thread_klass(), vmSymbols::run_method_name(), vmSymbols::void_method_signature(),THREAD);}
// thread_native使用JavaCalls调用Java方法Thread.run()
public class java.lang.Thread {
private Runnable target;
public void run() {
if (target != null) {
target.run(); // Thread.run()又调用Runnable.run()
}
}
...
}

JVM_ENTRY(void, JVM_StopThread(...))
// 获取JDK传入的ThreadDeath对象，确保不为空
oop java_throwable = JNIHandles::resolve(throwable);
if(java_throwable == NULL) {
THROW(vmSymbols::java_lang_NullPointerException());
}
...
// 如果要待停止的线程还活着
if (is_alive) {
// 如果停止当前线程
if (thread == receiver) {
// 抛出ThreadDeath（Error）停止
THROW_OOP(java_throwable);
} else {
// 否则停止其他线程，向虚拟机线程投递VM_ThreadStop
Thread::send_async_exception(java_thread, java_throwable);}
} else {
// 否则复活它（停止没有启动的线程是java.lang.Thread允许的行为）
java_lang_Thread::set_stillborn(java_thread);
}
JVM_END

public class ThreadTest {
public static void main(String[] args) {
new Thread(()->{
try{
Thread.currentThread().stop();
}catch (Error ignored){ }
System.out.println("still alive");
}).start();
}
}

class VM_ThreadStop: public VM_Operation {
private:
oop _thread; // 要停止的线程
oop _throwable; // ThreadDeath对象
public:
...
// 停止线程操作需要异步安全点
Mode evaluation_mode() const { return _async_safepoint; }
void doit() {
// 位于全局停顿的安全点
ThreadsListHandle tlh;
JavaThread* target = java_lang_Thread::thread(target_thread());
if(target != NULL && ...) {
// 发送线程停止命令
target->send_thread_stop(throwable());}
}};

JVM_ENTRY(void, JVM_Sleep(...))
JVMWrapper("JVM_Sleep");
// 如果睡眠时间<0，则抛出参数错误异常
if (millis < 0) {
THROW_MSG(...);
}
// 如果待睡眠的线程已经处于中断状态
if (Thread::is_interrupted (...) && !HAS_PENDING_EXCEPTION) {
THROW_MSG(...);
}
// 保存当前线程状态
JavaThreadSleepState jtss(thread);
// 如果睡眠时间为0，Thread.sleep()退化为Thread.yield()
if (millis == 0) {
os::naked_yield();
} 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) {
THROW_MSG(...);// 如果睡眠的时候有异步异常发生
}
}
// 恢复之前保存的线程状态
thread->osthread()->set_state(old_state);
}
JVM_END

public class ThreadTest {
public static void main(String[] args) {
Thread t = new Thread(()->{
synchronized (ThreadTest.class){ }
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
});synchronized (ThreadTest.class){
t.start();
t.interrupt();
}
}
}

int os::sleep(Thread* thread, jlong millis, bool interruptible) {
ParkEvent * const slp = thread->_SleepEvent ;
slp->reset() ;
OrderAccess::fence() ;
if (interruptible) {
jlong prevtime = javaTimeNanos();
for (;;) {
// 检查是否中断
if (os::is_interrupted(thread, true)) {
return OS_INTRPT;
}
// 更精确的睡眠时间
jlong newtime = javaTimeNanos();if (newtime - prevtime < 0) {
} else {
millis -= (newtime - prevtime)/NANOSECS_PER_MILLISEC;
}
if (millis <= 0) {
return OS_OK;
}
prevtime = newtime;
...
// 进行睡眠
slp->park(millis);
}
} else {
... // 类似上面的可中断逻辑，只是少了中断检查
}
}

void os::interrupt(Thread* thread) {
OSThread* osthread = thread->osthread();
// 如果线程没有处于中断状态，调用ParkEvent::unpark()通知睡眠线程中断if (!osthread->interrupted()) {
osthread->set_interrupted(true);
OrderAccess::fence();
ParkEvent * const slp = thread->_SleepEvent ;
if (slp != NULL) slp->unpark() ;
}
if (thread->is_Java_thread())
((JavaThread*)thread)->parker()->unpark();
ParkEvent * ev = thread->_ParkEvent ;
if (ev != NULL) ev->unpark() ;
}