说在前面：
对于Java线程的创建这个话题，似乎已经被"八股文"带偏～ 大部分Java程序员从"八股文"得知创建Java线程有N种方式，比如new Thread、new Runnable、Callable、线程池等等～ 而笔者写下这篇文章的目的是让大家从JVM源码的层面知道创建一个Java线程的方式。
版本信息：
jdk版本：jdk8u40
源码剖析：
public
class Thread implements Runnable {}从Thread类的继承关系来看，Thread类实现Runnable接口，不少读者可能不明白为什么需要实现Runnable接口，也不明白Thread和Runnable之间的关系，那么笔者不妨以自己见解解释一番～
Thread：Java层面开发者使用的类，开发者可以使用它创建、启动、关闭线程等等操作
Runnable：一个函数式接口，无返回值、无入参，用于回调，其中编写开发者的回调逻辑（逻辑入口）
Callable：一个函数式接口，有返回值、无入参，用于回调，其中编写开发者的回调逻辑（逻辑入口）
所以Thread和Runnable之间的关系一目了然，一个是Java线程的API集合，一个是定义了逻辑入口的接口
为什么Thread需要实现Runnable，因为当线程启动后，Thread需要帮开发者自动执行线程执行体，所以需要一个执行入口方法，刚好Runnable接口就提供了此入口～
接下来看一下Thread的构造方法。
public Thread(Runnable target) {
init(null, target, "Thread-" + nextThreadNum(), 0);
}
private void init(ThreadGroup g, Runnable target, String name,
long stackSize) {
init(g, target, name, stackSize, null, true);
}
private void init(ThreadGroup g, Runnable target, String name,
long stackSize, AccessControlContext acc,
boolean inheritThreadLocals) {
if (name == null) {
throw new NullPointerException("name cannot be null");
}
this.name = name;
Thread parent = currentThread();
SecurityManager security = System.getSecurityManager();
if (g == null) {
if (security != null) {
g = security.getThreadGroup();
}
if (g == null) {
g = parent.getThreadGroup();
}
}
g.checkAccess();
if (security != null) {
if (isCCLOverridden(getClass())) {
security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
}
}
g.addUnstarted();
this.group = g;
this.daemon = parent.isDaemon();
this.priority = parent.getPriority();
if (security == null || isCCLOverridden(parent.getClass()))
this.contextClassLoader = parent.getContextClassLoader();
else
this.contextClassLoader = parent.contextClassLoader;
this.inheritedAccessControlContext =
acc != null ? acc : AccessController.getContext();
this.target = target;
setPriority(priority);
if (inheritThreadLocals && parent.inheritableThreadLocals != null)
this.inheritableThreadLocals =
ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
this.stackSize = stackSize;
tid = nextThreadID();
}构造方法虽然比较长，但是都是对当前线程的属性赋值，并没有其他任何操作，所以笔者连注释都没有写。
写到这里，我们需要理解一个点，Java是没有能力创建底层的线程，这个需要交给JVM来创建，而这里new Thread创建的仅仅是Java层面表示的线程对象～
而JVM来创建线程，所以需要Java层面调用native方法，所以我们看到Thread中start方法。
public synchronized void start() {
// 此线程的状态如果不是创建状态就直接抛出非法逻辑异常。
if (threadStatus != 0)
throw new IllegalThreadStateException();
// 添加到对应的线程组中。
group.add(this);
boolean started = false;
try {
// Native方法，此方法会创建底层的线程，并且启动线程，并且执行线程的执行体（Runnable的run方法）
start0();
started = true; // 正常启动完毕。
} finally {
try {
if (!started) {
group.threadStartFailed(this);
}
} catch (Throwable ignore) {
}
}
}
private native void start0();start方法会去底层创建线程，并且启动线程，执行线程的执行体 ，所以需要看到start0这个native方法的实现，所以下面是C/C++的代码～
{"start0", "()V", (void *)&JVM_StartThread}
JVM_ENTRY(void, JVM_StartThread(JNIEnv* env, jobject jthread))
JVMWrapper("JVM_StartThread");
JavaThread *native_thread = NULL;
bool throw_illegal_thread_state = false;
{
MutexLocker mu(Threads_lock);
// 获取到Java开发者设置的栈大小，这个参数一般不会设置
jlong size =
java_lang_Thread::stackSize(JNIHandles::resolve_non_null(jthread));
size_t sz = size > 0 ? (size_t) size : 0;
// 创建底层的线程。
// 当创建好线程后，会回调thread_entry此方法。
native_thread = new JavaThread(&thread_entry, sz);
if (native_thread->osthread() != NULL) {
// 初始化线程，比如是否是守护线程，线程优先级。以及线程数量的统计。
native_thread->prepare(jthread);
}
}
// 设置成运行中状态
Thread::start(native_thread);
JVM_END因为JVM是c/c++编写，而c++是有面向对象的思想存在，所以在new JavaThread中，会执行构造方法，我们看到构造方法。
JavaThread::JavaThread(ThreadFunction entry_point, size_t stack_sz) :
Thread() // 调用父类构造方法
{
// 初始化参数
initialize();
_jni_attach_state = _not_attaching_via_jni;
// 设置执行入口，当底层线程创建好以后，会去回调此方法
set_entry_point(entry_point);
// 设置此线程的类型，当前线程是java_thread类型
os::ThreadType thr_type = os::java_thread;
thr_type = entry_point == &compiler_thread_entry ? os::compiler_thread :
os::java_thread;
// 真正的线程只有操作系统才有权利去创建，所以这里调用操作系统类库去创建。
os::create_thread(this, thr_type, stack_sz);
_safepoint_visible = false;
}
bool os::create_thread(Thread* thread, ThreadType thr_type, size_t stack_size) {
assert(thread->osthread() == NULL, "caller responsible");
OSThread* osthread = new OSThread(NULL, NULL);
osthread->set_thread_type(thr_type);
osthread->set_state(ALLOCATED);
thread->set_osthread(osthread);
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
………… // 省略一部分设置参数代码
// glibc guard page
pthread_attr_setguardsize(&attr, os::Linux::default_guard_size(thr_type));
ThreadState state;
{
pthread_t tid;
// java_start 作为统一的入口，后续再根据thread类型做分发（多态）。
int ret = pthread_create(&tid, &attr, (void* (*)(void*)) java_start, thread);
pthread_attr_destroy(&attr);
osthread->set_pthread_id(tid);
// Wait until child thread is either initialized or aborted
{
Monitor* sync_with_child = osthread->startThread_lock();
MutexLockerEx ml(sync_with_child, Mutex::_no_safepoint_check_flag);
while ((state = osthread->get_state()) == ALLOCATED) {
sync_with_child->wait(Mutex::_no_safepoint_check_flag);
}
}
if (lock) {
os::Linux::createThread_lock()->unlock();
}
}
return true;
}因为JVM是帮Java开发者实现了跨平台机制，所以需要适配所有OS平台，而我们只关心Linux操作系统，而Linux操作系统使用的是POSIX的线程标准，实现者肯定是Glibc类库，实现就是PThread线程库，而这里也是调用了pthread_create库函数创建了底层的线程（这里不懂没关系，只需要明白会去操作系统创建线程），并且设置线程的执行入口是java_start方法。
// pthread线程回调执行点。
static void *java_start(Thread *thread) {
………… // 省略大部分的设置参数和状态值的代码，方便观看核心源码
// 这里是区分JVM层面抽象的不同线程的不同执行点（多态）
// 而这里thread对象是JavaThread
thread->run();
return 0;
}
void JavaThread::run() {
………… // 省略大部分的设置参数和状态值的代码，方便观看核心源码
// 执行设置的入口
thread_main_inner();
}这里是pthread线程启动后回调的方法，这里会回调JavaThread的thread_main_inner方法。这里如果能看懂C++的读者会发现，这里使用多态思想非常完美～
void JavaThread::thread_main_inner() {
// 不存在异常
if (!this->has_pending_exception() &&
!java_lang_Thread::is_stillborn(this->threadObj())) {
HandleMark hm(this);
// 回调设置的入口
this->entry_point()(this, this);
}
DTRACE_THREAD_PROBE(stop, this);
// 执行到这里代表线程执行结束了，需要做释放工作。
this->exit(false);
delete this;
}经过一系列的回调，最终来到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,
KlassHandle(THREAD, SystemDictionary::Thread_klass()),
vmSymbols::run_method_name(),
vmSymbols::void_method_signature(),
THREAD);
}这里非常的简单，在JVM层面调用Java的方法，而这里调用的就是Thread类中run方法（也即调用Runnable接口的run方法）
@Override
public void run() {
// target参数往往是开发者传入的Runnable接口的实现类。
if (target != null) {
target.run(); // 调用开发者的逻辑
}
}上面的流程对于不懂JVM源码和不懂C++语言的读者来说非常吃力，甚至看不懂，这也很正常，源码层面是这样。但是读者会给你们做一个总结：
- 在Java层面调用Thread类的start方法
- start方法是一个native方法，会在c++层面创建JavaThread对象（因为c++也是面向对象）
- 在JavaThread的构造方法中会去创建OsThread对象（因为JVM是跨平台，存在很多个操作系统平台，所以需要一个OsThread做高度抽象）
- 在Linux操作系统平台中会去创建pthread线程（此线程可以理解为就是操作系统层面的线程）
- 创建完pthread线程后会经过一层一层的回调方法，最终回调thread_entry方法
- thread_entry方法中，会从JVM层面调用Java层面的方法，而调用的方法是Thread类中run方法，而Thread类是实现Runnable接口，所以也证明了文章开头说的Runnable 接口是作为一个执行入口
- 在Thread的run方法中，会去执行用户传入的Runnable接口，或者开发者重写了Thread的run方法。总之，这里就是回调开发者的逻辑。
- 所以Java的Thread创建入口就只有一个，就是Java的Thread类的start方法。
线程的关系图如上所述。
其实，你会发现，没有什么是中间抽一层不能解决的，每一层有每一层的职责，但是往往抽一层就需要有中间层的表示状态～
总结：
因为是深入到JVM源码层面，所以部分代码很多读者看不懂。但是代码是科学，他并不是神学，要论证真实性，必须要深入到源码层面。
