关于java:教小师妹学多线程一个有深度的例子

作者：小傅哥
博客：https://bugstack.cn

积淀、分享、成长，让本人和别人都能有所播种！😄

一、前言

对于在校学习期间的计算机、软件工程的学生来说，只有学到 Java 多线程，就开始犯迷糊了！

刚晓得咋关上 IDEA，吃力扒拉的写个 HelloWorld，就要上手搞多线程相对是史诗级了解难度。这货色怎么跑起来的 、 怎么还有一个 run 办法 、 各种状态是啥意思 、 还要休眠睡一会，纳尼？

以我的学习经验来说，一个知识点是否能疾速承受并学习到，往往是看有没有一个适合的场景和好的例子，来疏导读者学习到这样的技术，就像；

• Git：上厕所不叫上厕所，叫拉分支！
• Socket：厕所就是服务器，坑就是端口！
• 队列：上厕所🚽叫入队列，先进先出！
• 栈：去厨房🥣叫进栈，后进先出！
• 架构：三居的格局叫 MVC，四居的格局叫 DDD！
• 实践：系统结构设计定的好，有点 bug 没问题，能改。这就是茅坑跟坐便的区别。

除了有点滋味以外，这回是不记住了，咱们编程写代码的过程和咱们日常生活的例子，往往都是这样能够对应上，有了实在能够涉及的实物，再去理解编程就会更加容易，也很难遗记。

二、给小师妹一个脸红的多线程

一个最开始接触多线程常识的将来 500 强工程师，也可能须要翻很屡次书、写很多例子、敲很多代码，能力大略了解个 7788，不是这常识有多难，次要是例子不好，不进脑子。

那么，接下来咱们模仿鹿鼎记·丽春院，清倌喝茶吟诗聊风月日常。当有达官贵人来时，须要调配清倌给大老爷。两头会有一些期待、叫醒操作。只为让你更好的记住这样的案例，不要想歪喽。清倌人即是只卖艺欢场人，喊麦的。

1. wait & notify 期待和叫醒

案例代码

public class 丽春院 {public static void main(String[] args) {老鸨 鸨子 = new 老鸨();

        清倌 miss = new 清倌(鸨子);
        客官 guest = new 客官(鸨子);

        Thread t_miss = new Thread(miss);
        Thread t_guest = new Thread(guest);

        t_miss.start();
        t_guest.start();}

}

class 清倌 implements Runnable {

    老鸨 鸨子;

    public 清倌(老鸨 鸨子) {this. 鸨子 = 鸨子;}

    @Override
    public void run() {
        int i = 1;
        while (true) {
            try {Thread.sleep(1000);
            } catch (InterruptedException e1) {e1.printStackTrace();
            }
            if (i == 1) {
                try {鸨子. 在岗清倌("苍原野子", "500 日元");
                } catch (InterruptedException e) {e.printStackTrace();
                }
            } else {
                try {鸨子. 在岗清倌("花田岗子", "800 日元");
                } catch (InterruptedException e) {e.printStackTrace();
                }
            }
            i = (i + 1) % 2;
        }
    }

}

class 客官 implements Runnable {

    老鸨 鸨子;

    public 客官(老鸨 鸨子) {this. 鸨子 = 鸨子;}

    @Override
    public void run() {while (true) {
            try {Thread.sleep(1000);
            } catch (InterruptedException e1) {e1.printStackTrace();
            }
            try {鸨子. 喝茶吟诗聊风月();
            } catch (InterruptedException e) {e.printStackTrace();
            }
        }
    }

}

class 老鸨 {

    private String 清倌 = null;
    private String price = null;
    private boolean 工作状态 = true;

    public synchronized void 在岗清倌(String 清倌, String price) throws InterruptedException {if (! 工作状态)
            wait();// 期待
        this. 清倌 = 清倌;
        this.price = price;
        工作状态 = false;
        notify();// 叫醒}

    public synchronized void 喝茶吟诗聊风月() throws InterruptedException {if (工作状态)
            wait();// 期待
        System.out.println("聊风月：" + 清倌);
        System.out.println("茶水费：" + price);
        System.out.println("" +"  "+"  "+"  "+"  "+"  "+"  "+"  "+"  "+"  "+ 清倌 +" 完事 "+" 筹备 ... ...");
        System.out.println("****************************************");
        工作状态 = true;
        notify();// 叫醒}

}

测试后果

聊风月：苍原野子
茶水费：500 日元
                    苍原野子完事筹备 ... ...
****************************************
聊风月：花田岗子
茶水费：800 日元
                    花田岗子完事筹备 ... ...
****************************************
聊风月：苍原野子
茶水费：500 日元
                    苍原野子完事筹备 ... ...
****************************************

...

• 小师妹，说看完例子就懂了！
• 首先这样的例子它贴近于电视剧、影视作品中经常出现的场景。把生存与技术联合后，你会发现本来不好了解的技术点就好了解了！
• wait 和 notify/nofityall，是一对办法，有一个期待，就会有一个叫醒，否则程序就夯在那不动了。对于这部分会应用到的 synchronized 在之前小傅哥有深刻的源码剖析，讲到它是怎么加锁在对象头的，如果你遗记了能够翻翻看《synchronized 解毒，分析源码深度剖析！》
• 理解了根底的例子，接下来在深刻学习线程中的各项技术点，就比拟容易在头脑中带着场景去验证和学习了。

2. yield

yield 办法让出 CPU，但不肯定，肯定让出！。这种可能会用在一些同时启动的线程中，依照优先级保障重要线程的执行，也能够是其余一些非凡的业务场景（例如这个线程内容很耗时，又不那么重要，能够放在前面）。

为了验证这个办法，咱们做一个例子：启动 50 个线程进行，每个线程都进行 1000 次的加和计算。其中 10 个线程会执行让出 CPU 操作。那么，如果让出 CPU 那 10 个线程的计算加和工夫都比拟长，阐明的确在进行让出操作。

案例代码

private static volatile Map<String, AtomicInteger> count = new ConcurrentHashMap<>();
static class Y implements Runnable {
    private String name;
    private boolean isYield;
    public Y(String name, boolean isYield) {
        this.name = name;
        this.isYield = isYield;
    }
    @Override
    public void run() {long l = System.currentTimeMillis();
        for (int i = 0; i < 1000; i++) {if (isYield) Thread.yield();
            AtomicInteger atomicInteger = count.get(name);
            if (null == atomicInteger) {count.put(name, new AtomicInteger(1));
                continue;
            }
            atomicInteger.addAndGet(1);
            count.put(name, atomicInteger);
        }
        System.out.println("线程编号：" + name + "执行实现耗时：" + (System.currentTimeMillis() - l) + "(毫秒)" + (isYield ? "让出 CPU----------------------" : "不让 CPU"));
    }
}

public static void main(String[] args) {for (int i = 0; i < 50; i++) {if (i < 10) {new Thread(new Y(String.valueOf(i), true)).start();
            continue;
        }
        new Thread(new Y(String.valueOf(i), false)).start();}
}

测试后果

线程编号：10 执行实现耗时：2 (毫秒)不让 CPU
线程编号：11 执行实现耗时：2 (毫秒)不让 CPU
线程编号：15 执行实现耗时：1 (毫秒)不让 CPU
线程编号：14 执行实现耗时：1 (毫秒)不让 CPU
线程编号：19 执行实现耗时：1 (毫秒)不让 CPU
线程编号：18 执行实现耗时：1 (毫秒)不让 CPU
线程编号：22 执行实现耗时：0 (毫秒)不让 CPU
线程编号：26 执行实现耗时：0 (毫秒)不让 CPU
线程编号：27 执行实现耗时：1 (毫秒)不让 CPU
线程编号：30 执行实现耗时：0 (毫秒)不让 CPU
线程编号：42 执行实现耗时：1 (毫秒)不让 CPU
线程编号：45 执行实现耗时：1 (毫秒)不让 CPU
线程编号：43 执行实现耗时：1 (毫秒)不让 CPU
线程编号：46 执行实现耗时：0 (毫秒)不让 CPU
线程编号：47 执行实现耗时：0 (毫秒)不让 CPU
线程编号：35 执行实现耗时：0 (毫秒)不让 CPU
线程编号：33 执行实现耗时：0 (毫秒)不让 CPU
线程编号：32 执行实现耗时：0 (毫秒)不让 CPU
线程编号：41 执行实现耗时：0 (毫秒)不让 CPU
线程编号：48 执行实现耗时：1 (毫秒)不让 CPU
线程编号：6 执行实现耗时：15 (毫秒)让出 CPU----------------------
线程编号：7 执行实现耗时：15 (毫秒)让出 CPU----------------------
线程编号：49 执行实现耗时：2 (毫秒)不让 CPU
线程编号：29 执行实现耗时：1 (毫秒)不让 CPU
线程编号：2 执行实现耗时：17 (毫秒)让出 CPU----------------------
线程编号：1 执行实现耗时：11 (毫秒)让出 CPU----------------------
线程编号：4 执行实现耗时：15 (毫秒)让出 CPU----------------------
线程编号：8 执行实现耗时：12 (毫秒)让出 CPU----------------------
线程编号：5 执行实现耗时：12 (毫秒)让出 CPU----------------------
线程编号：9 执行实现耗时：12 (毫秒)让出 CPU----------------------
线程编号：0 执行实现耗时：21 (毫秒)让出 CPU----------------------
线程编号：3 执行实现耗时：21 (毫秒)让出 CPU----------------------

• 从测试后果能够看到，那些让出 CPU 的，执行完计算曾经在 10 毫秒以上，阐明咱们的测试是成果的。

3. join

join 是两个线程的合并吗？不是的！

join 是让线程进入 wait，当线程执行结束后，会在 JVM 源码中找到，它执行结束后，其实执行 notify，也就是 期待 和 叫醒 操作。

源码：jdk8u_hotspot/blob/master/src/share/vm/runtime/thread.cpp

void JavaThread::exit(bool destroy_vm, ExitType exit_type) {// Notify waiters on thread object. This has to be done after exit() is called
    // on the thread (if the thread is the last thread in a daemon ThreadGroup the
    // group should have the destroyed bit set before waiters are notified).
    ensure_join(this);
}
static void ensure_join(JavaThread* thread) {
  // 叫醒
  java_lang_Thread::set_thread(threadObj(), NULL);
  lock.notify_all(thread);
}

好的，就是这里！lock.notify_all(thread)，执行到这，就对上了。

案例代码

Thread thread = new Thread(() -> {System.out.println("thread before");
    try {Thread.sleep(3000);
    } catch (Exception e) {e.printStackTrace();
    }
    System.out.println("thread after");
});
thread.start();
System.out.println("main begin！");
thread.join();
System.out.println("main end！");

测试后果

main begin！thread before
thread after
main end！Process finished with exit code 0

首先 join() 是一个 synchronized 办法，外面调用了 wait()，这个过程的目标是让持有这个同步锁的线程进入期待，那么谁持有了这个同步锁呢？答案是主线程，因为主线程调用了 threadA.join()办法，相当于在 threadA.join()代码这块写了一个同步代码块，谁去执行了这段代码呢，是主线程，所以主线程被 wait()了。而后在子线程 threadA 执行结束之后，JVM 会调用 lock.notify_all(thread); 唤醒持有 threadA 这个对象锁的线程，也就是主线程，会继续执行。

• 这部分验证的次要体现就是加了 thread.join() 后，会影响到输入后果。如果不加，main end！ 会优先 thread after 提前打印进去。
• join() 是一个 synchronized 办法，外面调用了 wait() 办法，让持有以后同步锁的线程进入期待状态，也就是主线程。当子线程执行结束后，咱们从源码中能够看到 JVM 调用了 lock.notify_all(thread) 所以唤醒了主线程继续执行。

三、线程启动过程

new Thread(() -> {// todo}).start();

咳咳 ，Java 的线程创立和启动非常简单，但如果问 一个线程是怎么启动起来的 往往并不分明，甚至不晓得为什么启动时是 调用 start()，而不是 调用 run()办法呢？

那么，为了让大家有一个更直观的认知，咱们先站在上帝视角。把这段 Java 的线程代码，到 JDK 办法应用，以及 JVM 的相应处理过程，展现给大家，以不便咱们后续逐渐剖析。

以上，就是一个线程启动的整体过程剖析，会波及到如下知识点：

• 线程的启动会波及到本地办法（JNI）的调用，也就是那局部 C++ 编写的代码。
• JVM 的实现中会有不同操作系统对线程的对立解决，比方：Win、Linux、Unix。
• 线程的启动会波及到线程的生命周期状态（RUNNABLE），以及唤醒操作，所以最终会有回调操作。也就是调用咱们的 run() 办法

接下来，咱们就开始逐渐剖析每一步源码的执行内容，从而理解线程启动过程。

1. Thread start UML 图

如图 19-2 是线程的启动过程时序图，整体的链路较长，会波及到 JVM 的操作。外围源码如下：

1. Thread.c：https://github.com/unofficial-openjdk/openjdk/blob/jdk/jdk/src/java.base/share/native/libjava/Thread.c
2. jvm.cpp：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/share/vm/prims/jvm.cpp
3. thread.cpp：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/share/vm/runtime/thread.cpp
4. os.cpp：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/share/vm/runtime/os.hpp
5. os_linux.cpp：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/os/linux/vm/os_linux.cpp
6. os_windows.cpp：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/os/windows/vm/os_windows.cpp
7. vmSymbols.hpp：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/share/vm/classfile/vmSymbols.hpp

2. Java 层面 Thread 启动

2.1 start() 办法

new Thread(() -> {// todo}).start();

// JDK 源码
public synchronized void start() {if (threadStatus != 0)
        throw new IllegalThreadStateException();

    group.add(this);
    boolean started = false;
    try {start0();
        started = true;
    } finally {
        try {if (!started) {group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {}}
}

• 线程启动办法 start()，在它的办法英文正文中曾经把核心内容形容进去。Causes this thread to begin execution; the Java Virtual Machine calls the run method of this thread. 这段话的意思是：由 JVM 调用此线程的 run 办法，使线程开始执行。其实这就是一个 JVM 的回调过程，下文源码剖析中会讲到
• 另外 start() 是一个 synchronized 办法，但为了防止屡次调用，在办法中会由线程状态判断。threadStatus != 0。
• group.add(this)，是把以后线程退出到线程组，ThreadGroup。
• start0()，是一个本地办法，通过 JNI 形式调用执行。这一步的操作才是启动线程的外围步骤。

2.2 start0() 本地办法

// 本地办法 start0
private native void start0();

// 注册本地办法
public class Thread implements Runnable {
    /* Make sure registerNatives is the first thing <clinit> does. */
    private static native void registerNatives();
    static {registerNatives();
    }
    // ...
}    

• start0()，是一个本地办法，用于启动线程。
• registerNatives()，这个办法是用于注册线程执行过程中须要的一些本地办法，比方：start0、isAlive、yield、sleep、interrupt0等。

registerNatives，本地办法定义在 Thread.c 中，以下是定义的外围源码：

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},
    {"interrupt0",       "()V",        (void *)&JVM_Interrupt},
    {"holdsLock",        "(" OBJ ")Z", (void *)&JVM_HoldsLock},
    {"getThreads",        "()[" THD,   (void *)&JVM_GetAllThreads},
    {"dumpThreads",      "([" THD ")[[" STE, (void *)&JVM_DumpThreads},
    {"setNativeName",    "(" STR ")V", (void *)&JVM_SetNativeThreadName},
};

• 源码：https://github.com/unofficial-openjdk/openjdk/blob/jdk/jdk/src/java.base/share/native/libjava/Thread.c
• 从定义中能够看到，start0 办法会执行 &JVM_StartThread 办法，最终由 JVM 层面启动线程。

3. JVM 创立线程

3.1 JVM_StartThread

源码：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/share/vm/prims/jvm.cpp

JVM_ENTRY(void, JVM_StartThread(JNIEnv* env, jobject jthread))
  JVMWrapper("JVM_StartThread");
  JavaThread *native_thread = NULL;
  
  // 创立线程
  native_thread = new JavaThread(&thread_entry, sz);
  // 启动线程
  Thread::start(native_thread);

JVM_END

• 这部分代码比拟多，但核心内容次要是 创立线程 和启动线程，另外 &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,
                          KlassHandle(THREAD, SystemDictionary::Thread_klass()),
                          vmSymbols::run_method_name(),
                          vmSymbols::void_method_signature(),
                          THREAD);
}

重点，在创立线程引入这个线程入口的办法时，thread_entry 中包含了 Java 的回调函数 JavaCalls::call_virtual。这个回调函数会由 JVM 调用。

vmSymbols::run_method_name()，就是那个被回调的办法，源码如下：

源码：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/share/vm/classfile/vmSymbols.hpp

#define VM_SYMBOLS_DO(template, do_alias)
template(run_method_name, "run") 

• 这个 run 就是咱们的 Java 程序中会被调用的 run 办法。接下来咱们持续依照代码执行链路，寻找到这个被回调的办法在什么时候调用的。

3.2 JavaThread

native_thread = new JavaThread(&thread_entry, sz);

接下来，咱们持续看 JavaThread 的源码执行内容。

源码：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/share/vm/runtime/thread.cpp

JavaThread::JavaThread(ThreadFunction entry_point, size_t stack_sz) :
  Thread()
#if INCLUDE_ALL_GCS
  , _satb_mark_queue(&_satb_mark_queue_set),
  _dirty_card_queue(&_dirty_card_queue_set)
#endif // INCLUDE_ALL_GCS
{if (TraceThreadEvents) {tty->print_cr("creating thread %p", this);
  }
  initialize();
  _jni_attach_state = _not_attaching_via_jni;
  set_entry_point(entry_point);
  // Create the native thread itself.
  // %note runtime_23
  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);
}

• ThreadFunction entry_point，就是咱们下面的 thread_entry 办法。
• size_t stack_sz，示意过程中已有的线程个数。
• 这两个参数，都会传递给 os::create_thread 办法，用于创立线程应用。

3.3 os::create_thread

源码：

• os_linux.cpp：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/os/linux/vm/os_linux.cpp
• os_windows.cpp：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/os/windows/vm/os_windows.cpp

家喻户晓，JVM 是个啥！，所以它的 OS 服务实现，Liunx 还有 Windows 等，都会实现线程的创立逻辑。这有点像适配器模式

os_linux -> os::create_thread

bool os::create_thread(Thread* thread, ThreadType thr_type, size_t stack_size) {assert(thread->osthread() == NULL, "caller responsible");

  // Allocate the OSThread object
  OSThread* osthread = new OSThread(NULL, NULL);
  // Initial state is ALLOCATED but not INITIALIZED
  osthread->set_state(ALLOCATED);
  
  pthread_t tid;
  int ret = pthread_create(&tid, &attr, (void* (*)(void*)) java_start, thread);

  return true;
}

• osthread->set_state(ALLOCATED)，初始化已调配的状态，但此时并没有初始化。
• pthread_create，是类 Unix 操作系统（Unix、Linux、Mac OS X 等）的创立线程的函数。
• java_start，重点关注类，是理论创立线程的办法。

3.4 java_start

源码：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/os/linux/vm/os_linux.cpp

static void *java_start(Thread *thread) {

  // 线程 ID
  int pid = os::current_process_id();

  // 设置线程
  ThreadLocalStorage::set_thread(thread);

  // 设置线程状态：INITIALIZED 初始化实现
  osthread->set_state(INITIALIZED);
  
  // 唤醒所有线程
  sync->notify_all();

 // 循环，初始化状态，则统一期待 wait
 while (osthread->get_state() == INITIALIZED) {sync->wait(Mutex::_no_safepoint_check_flag);
 }

  // 期待唤醒后，执行 run 办法
  thread->run();

  return 0;
}

• JVM 设置线程状态，INITIALIZED 初始化实现。
• sync->notify_all()，唤醒所有线程。
• osthread->get_state() == INITIALIZED，while 循环期待
• thread->run()，是期待线程唤醒后，也就是状态变更后，能力执行到。这在咱们的线程执行 UML 图中，也有所体现

4. JVM 启动线程

JVM_ENTRY(void, JVM_StartThread(JNIEnv* env, jobject jthread))
  JVMWrapper("JVM_StartThread");
  JavaThread *native_thread = NULL;
  
  // 创立线程
  native_thread = new JavaThread(&thread_entry, sz);
  // 启动线程
  Thread::start(native_thread);

JVM_END

• JVM_StartThread 中有两步，创立（new JavaThread）、启动（Thread::start）。创立的过程聊完了，接下来咱们聊启动。

4.1 Thread::start

源码：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/share/vm/runtime/thread.cpp

void Thread::start(Thread* thread) {trace("start", thread);

  if (!DisableStartThread) {if (thread->is_Java_thread()) {java_lang_Thread::set_thread_status(((JavaThread*)thread)->threadObj(),
                                          java_lang_Thread::RUNNABLE);
    }
    // 不同的 OS 会有不同的启动代码逻辑
    os::start_thread(thread);
  }
}

• 如果没有禁用线程 DisableStartThread 并且是 Java 线程 thread->is_Java_thread()，那么设置线程状态为 RUNNABLE。
• os::start_thread(thread)，调用线程启动办法。不同的 OS 会有不同的启动代码逻辑

4.2 os::start_thread(thread)

源码：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/share/vm/runtime/os.hpp

void os::start_thread(Thread* thread) {
  // guard suspend/resume
  MutexLockerEx ml(thread->SR_lock(), Mutex::_no_safepoint_check_flag);
  OSThread* osthread = thread->osthread();
  osthread->set_state(RUNNABLE);
  pd_start_thread(thread);
}

• osthread->set_state(RUNNABLE)，设置线程状态 RUNNABLE
• pd_start_thread(thread)，启动线程，这个就由各个 OS 实现类，实现各自零碎的启动办法了。比方，windows 零碎和 Linux 零碎的代码是齐全不同的。

4.3 pd_start_thread(thread)

源码：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/os/linux/vm/os_linux.cpp

void os::pd_start_thread(Thread* thread) {OSThread * osthread = thread->osthread();
  assert(osthread->get_state() != INITIALIZED, "just checking");
  Monitor* sync_with_child = osthread->startThread_lock();
  MutexLockerEx ml(sync_with_child, Mutex::_no_safepoint_check_flag);
  sync_with_child->notify();}

• 这部分代码 notify() 最要害，它能够唤醒线程。
• 线程唤醒后，3.4 中的 thread->run(); 就能够继续执行了。

5. JVM 线程回调

5.1 thread->run()[JavaThread::run()]

源码：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/share/vm/runtime/thread.cpp

// The first routine called by a new Java thread
void JavaThread::run() {
  // ... 初始化线程操作
  
  thread_main_inner();}

• os_linux.cpp 类中的 java_start 里的 thread->run()，最终调用的就是 thread.cpp 的 JavaThread::run() 办法。
• 这部分还须要持续往下看，thread_main_inner(); 办法。

5.2 thread_main_inner

源码：https://github.com/JetBrains/jdk8u_hotspot/blob/master/src/share/vm/runtime/thread.cpp

void JavaThread::thread_main_inner() {if (!this->has_pending_exception() &&
      !java_lang_Thread::is_stillborn(this->threadObj())) {
    {ResourceMark rm(this);
      this->set_native_thread_name(this->get_thread_name());
    }
    HandleMark hm(this);
    this->entry_point()(this, this);
  }

  DTRACE_THREAD_PROBE(stop, this);

  this->exit(false);
  delete this;
}

• 这里有你相熟的设置的线程名称，this->set_native_thread_name(this->get_thread_name())。
• this->entry_point()，理论调用的就是 3.1 中的 thread_entry 办法。
• thread_entry，办法最终会调用到 JavaCalls::call_virtual 里的 vmSymbols::run_method_name()。也就是 run() 办法，至此线程启动实现。 终于串回来了！

四、Thread 状态关系

Java 的线程状态形容在枚举类 java.lang.Thread.State 中，共包含如下五种状态：

public enum State {NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED;}

这五种状态形容了一个线程的生命周期，其实这种状态码的定义在咱们日常的业务开发中，也经常出现。比方：一个流动的提交、审核、回绝、批改、通过、运行、敞开等，是相似的。那么线程的状态是通过下图的形式进行流转的，如图 20-1

• New：新创建的一个线程，处于期待状态。
• Runnable：可运行状态，并不是曾经运行，具体的线程调度各操作系统决定。在 Runnable 中蕴含了 Ready、Running 两个状态，当线程调用了 start() 办法后，线程则处于就绪 Ready 状态，期待操作系统调配 CPU 工夫片，调配后则进入 Running 运行状态。此外当调用 yield() 办法后，只是 谦让 的容许以后线程让出 CPU，但具体让不让不肯定，由操作系统决定。如果让了，那么以后线程则会处于 Ready 状态持续竞争 CPU，直至执行。
• Timed_waiting：指定工夫内让出 CPU 资源，此时线程不会被执行，也不会被系统调度，直到等待时间到期后才会被执行。下列办法都能够触发：Thread.sleep、Object.wait、Thread.join、LockSupport.parkNanos、LockSupport.parkUntil。
• Wating：可被唤醒的期待状态，此时线程不会被执行也不会被系统调度。此状态能够通过 synchronized 取得锁，调用 wait 办法进入期待状态。最初通过 notify、notifyall 唤醒。下列办法都能够触发：Object.wait、Thread.join、LockSupport.park。
• Blocked：当产生锁竞争状态下，没有取得锁的线程会处于挂起状态。例如 synchronized 锁，先取得的先执行，没有取得的进入阻塞状态。
• Terminated：这个是终止状态，从 New 到 Terminated 是不可逆的。个别是程序流程失常完结或者产生了异样。

这里参考枚举State 类的英文正文理解了每一个状态码的含意，接下来咱们去尝试操作线程办法，把这些状态体现进去。

1. NEW

Thread thread = new Thread(() -> {});
System.out.println(thread.getState());

// NEW

• 这个状态很简略，就是线程创立还没有启动时就是这个状态。

2. RUNNABLE

Thread thread = new Thread(() -> {});
// 启动
thread.start();
System.out.println(thread.getState());

// RUNNABLE

• 创立的线程启动后 start()，就会进入 RUNNABLE 状态。但此时并不一定在执行，而是说这个线程曾经就绪，能够竞争 CPU 资源。

3. BLOCKED

Object obj = new Object();
new Thread(() -> {synchronized (obj) {
        try {Thread.sleep(10000);
        } catch (InterruptedException e) {e.printStackTrace();
        }
    }
}).start();

Thread thread = new Thread(() -> {synchronized (obj) {
        try {obj.wait();
        } catch (InterruptedException e) {e.printStackTrace();
        }
    }
});

thread.start();
while (true) {Thread.sleep(1000);
    System.out.println(thread.getState());
}

// BLOCKED
// BLOCKED
// BLOCKED

• 这段代码略微有点长，次要是为了让两个线程产生锁竞争。
• 第一个线程，synchronized 获取锁后休眠，不开释锁。
• 第二个线程，synchronized 获取不到锁，会被挂起。
• 那么最初的输入后果就会是，BLOCKED

4. WAITING

Object obj = new Object();
Thread thread = new Thread(() -> {synchronized (obj) {
        try {obj.wait();
        } catch (InterruptedException e) {e.printStackTrace();
        }
    }
});

thread.start();

while (true) {Thread.sleep(1000);
    System.out.println(thread.getState());
}

// WAITING
// WAITING
// WAITING

• 只有在 synchronized 代码块或者润饰的办法中，调用 wait 办法，又没有被 notify 就会进入 WAITING 状态。
• 另外 Thread.join 源码中也是调用的 wait 办法，所以也会让线程进入期待状态。

5. TIMED_WAITING

Object obj = new Object();
Thread thread = new Thread(() -> {synchronized (obj) {
        try {Thread.sleep(100000);
        } catch (InterruptedException e) {e.printStackTrace();
        }
    }
});
thread.start();

while (true) {Thread.sleep(1000);
    System.out.println(thread.getState());
}

// TIMED_WAITING
// TIMED_WAITING
// TIMED_WAITING

• 有了下面状态获取的比照，这个状态的获取就没什么难度了。只有改成 Thread.sleep(100000); 就能够了。

6. TERMINATED

Thread thread = new Thread(() -> {});
thread.start();

System.out.println(thread.getState());
System.out.println(thread.getState());
System.out.println(thread.getState());

// RUNNABLE
// TERMINATED
// TERMINATED

• 这个就比较简单了，只有一个线程运行完，它的生命周期完结了，就进入了 TERMINATED 状态。

五、总结

• 线程的启动过程波及到了 JVM 的参加，所以如果没有认真理解过，的确很难从一个本地办法理解的如此透彻。
• 整个源码剖析能够联合着代码调用 UML 时序图进行学习，根本外围过程包含：Java 创立线程和启动 、 调用本地办法 start0()、JVM 中 JVM_StartThread 的创立和启动 、 设置线程状态期待被唤醒 、 依据不同的 OS 启动线程并唤醒 、 最初回调 run() 办法启动 Java 线程。
• 线程状态和状态的转换也是面试中必问的问题，但除了面试是咱们本人在开发中，如果真的应用线程，是十分有必要理解线程状态是如何转换的。
• 线程的一些深刻学习都是在调用本地办法，也就是须要理解到 JVM 层面，能力更加粗浅的见到 c ++ 代码是如何实现这部分逻辑的。

六、系列举荐

• 讲道理，只有你是一个爱折腾的程序员，毕业找工作真的不须要再花钱培训！
• 工作两年简历写成这样，谁要你呀！
• 《Java 面经手册》PDF，全书 417 页 11.5 万字，完稿 & 发版！
• synchronized 解毒，分析源码深度剖析！
• BATJTMD，大厂招聘，都招什么样 Java 程序员？