共计 5881 个字符，预计需要花费 15 分钟才能阅读完成。
咱们都晓得，一个线程间接对应了一个 Thread 对象, 在刚开始学习线程的时候咱们也晓得启动线程是通过 start() 办法, 而并非 run() 办法。
那这是为什么呢？
如果你相熟 Thread 的代码的话, 你应该晓得在这个类加载的时候会注册一些 native 办法
public
class Thread implements Runnable {
/* Make sure registerNatives is the first thing <clinit> does. */
private static native void registerNatives();
static {registerNatives();
}
}
复制代码 一看到 native 我就想起了 JNI,registerNatives() 实际上就是 java 办法和 C /C++ 的函数对应。在首次加载的时候就会注册这些 native 办法。Thread 中有很多 native 办法，大家有趣味的能够去看看。
对于 JNI 办法的命名, 咱们能够这样测试，咱们用 java 申明一个 native 办法，而后先应用 javac 编译源文件 (比方 javac main.java), 而后在应用 javah 即可生成头文件 (javah main), 关上这个头文件你就晓得办法命名是如何的了
咱们在 JVM 源码中搜寻 Java_java_lang_Thread_registerNatives 能够看到 registerNatives 办法的具体实现
static JNINativeMethod methods[] = {{"start0", "()V", (void *)&JVM_StartThread},
{"stop0", "(" OBJ ")V", (void *)&JVM_StopThread},
{"isAlive", "()Z", (void *)&JVM_IsThreadAlive},
{"suspend0", "()V", (void *)&JVM_SuspendThread},
{"resume0", "()V", (void *)&JVM_ResumeThread},
{"setPriority0", "(I)V", (void *)&JVM_SetThreadPriority},
{"yield", "()V", (void *)&JVM_Yield},
{"sleep", "(J)V", (void *)&JVM_Sleep},
{"currentThread", "()" THD, (void *)&JVM_CurrentThread},
{"countStackFrames", "()I", (void *)&JVM_CountStackFrames},
{"interrupt0", "()V", (void *)&JVM_Interrupt},
{"isInterrupted", "(Z)Z", (void *)&JVM_IsInterrupted},
{"holdsLock", "(" OBJ ")Z", (void *)&JVM_HoldsLock},
{"getThreads", "()[" THD, (void *)&JVM_GetAllThreads},
{"dumpThreads", "([" THD ")[[" STE, (void *)&JVM_DumpThreads},
{"setNativeName", "(" STR ")V", (void *)&JVM_SetNativeThreadName},
};
JNIEXPORT void JNICALL
Java_java_lang_Thread_registerNatives(JNIEnv *env, jclass cls)
{(*env)->RegisterNatives(env, cls, methods, ARRAY_LENGTH(methods));
}
复制代码 能够看到，在 registerNatives 函数中，注册了很多的 native 办法比方这里的 start0() 办法。
所有对 JNI 函数的调用都应用了 env 指针, 该指针是对每一个本地办法的第一个参数。env 指针是函数指针表的指针。咱们能够在 docs.oracle.com/javase/8/do…中找到 JNI API
在 Thread.start() 办法中，理论就是通过调用 start0() 办法来启动线程的。
public synchronized void start() {if (threadStatus != 0)
throw new IllegalThreadStateException();
group.add(this);
boolean started = false;
try {// 次要调用了 start0() 这个 native 办法来启动线程
start0();
started = true;
} finally {
try {if (!started) {group.threadStartFailed(this);
}
} catch (Throwable ignore) {
/* do nothing. If start0 threw a Throwable then
it will be passed up the call stack */
}
}
}
private native void start0();
复制代码 而 JNINativeMethod 这个数据结构定义如下:
typedef struct {
char *name;
char *signature;
void *fnPtr;
}
复制代码 因而 start0() 这个办法对应的本地函数是 JVM_StartThread
{"start0", "()V", (void *)&JVM_StartThread}
复制代码 咱们接下来看 JVM_StartThread 的办法实现
JVM_ENTRY(void, JVM_StartThread(JNIEnv* env, jobject jthread))
JVMWrapper("JVM_StartThread");
JavaThread *native_thread = NULL;
bool throw_illegal_thread_state = false;
{
// Ensure that the C++ Thread and OSThread structures aren't freed before
// we operate.
MutexLocker mu(Threads_lock);
// 从 JDK5 开始，应用 java.lang.Thread threadStatus 来避免重新启动一个曾经启动的线程
if (java_lang_Thread::thread(JNIHandles::resolve_non_null(jthread)) != NULL) {throw_illegal_thread_state = true;} else {
jlong size =
java_lang_Thread::stackSize(JNIHandles::resolve_non_null(jthread));
NOT_LP64(if (size > SIZE_MAX) size = SIZE_MAX;)
size_t sz = size > 0 ? (size_t) size : 0;
// 创立 Java 线程
native_thread = new JavaThread(&thread_entry, sz);
if (native_thread->osthread() != NULL) {native_thread->prepare(jthread);
}
}
}
if (throw_illegal_thread_state) {THROW(vmSymbols::java_lang_IllegalThreadStateException());
}
// 省略了局部代码
// 将线程状态设置为 Runnable, 示意能够被运行
Thread::start(native_thread);
JVM_END
复制代码 下面代码次要做了三件事件
- 判断以后线程状态是否非法，不非法抛出 IllegalThreadStateException
- 创立一个 Java 线程 (咱们须要重点关注的)
- 将线程状态设置为 Runnable
如果面试官当前再问你两次调用 start() 办法会怎么, 你就大胆而动摇的回复说抛出 IllegalThreadStateException。
在 JavaThread 构造函数中理论调用的是 os::create_thread 办法
bool os::create_thread(Thread* thread, ThreadType thr_type,
size_t req_stack_size) {OSThread* osthread = new OSThread(NULL, NULL);
if (osthread == NULL) {return false;}
osthread->set_thread_type(thr_type);
osthread->set_state(ALLOCATED);
thread->set_osthread(osthread);
// init thread attributes
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
size_t stack_size = os::Posix::get_initial_stack_size(thr_type, req_stack_size);
int status = pthread_attr_setstacksize(&attr, stack_size);
ThreadState state;
{
pthread_t tid;
// 创立线程
int ret = pthread_create(&tid, &attr, (void* (*)(void*)) thread_native_entry, thread);
// 省略其余代码...
}
return true;
}
复制代码 pthread_create 函数作用是创立一个线程, 它的第三个参数是线程运行函数的起始地址, 第四个参数是运行函数参数
IEEE 规范 1003.1c 中定义了线程的规范, 它定义的线程包叫做 Pthread, 大部分 UNIX 零碎都反对这个规范。
咱们的 thread_native_entry 理论传入的是 JavaThread 这个对象, 所以最终会调用 JavaThread::run()(thread.cpp 中)
void JavaThread::run() {
...
thread_main_inner();
...
}
void JavaThread::thread_main_inner() {
...
this->entry_point()(this,this);
...
}
复制代码 thread_main_inner 函数中 entry_point 的返回值实际上是咱们在创立 JavaThread 的时候传入的第一个参数 thread_entry。而 thread_entry 指针指向的函数如下:
static void thread_entry(JavaThread* thread, TRAPS) {HandleMark hm(THREAD);
Handle obj(THREAD, thread->threadObj());
JavaValue result(T_VOID);
JavaCalls::call_virtual(&result,
obj,
SystemDictionary::Thread_klass(),
// run 办法名称 run
vmSymbols::run_method_name(),
// 办法签名 ()V
vmSymbols::void_method_signature(),
THREAD);
}
复制代码 这样咱们就最终通过 JavaCalls 调用了 run 办法。
总结
new Thread 只是创立了一个一般的 Java 对象, 只有在调用了 start() 办法之后才会创立一个真正的线程, 在 JVM 外部会在创立线程之后调用 run() 办法, 执行相应的业务逻辑。
因为 Java 中线程最终还是和操作系统线程挂钩了的, 所以线程资源是一个很重要的资源, 为了复用咱们个别是通过线程池的形式来应用线程。
参考：《2020 最新 Java 根底精讲视频教程和学习路线！》
链接：https://juejin.cn/post/685805…