@TOC

敞开心扉，一起聊聊Java多线程（结尾有福利~）

明天！咱们来聊一聊 多线程 ~

咱们都晓得，不管在是面试还是工作中，多线程都是一些陈词滥调的话题，

置信正在浏览得你，脑海中未然浮现出多线程的相干常识，那么，咱们来一起回顾下吧 ~

==留神：本片博文后面内容重点在于回顾，前面内容重点解说线程的生命周期以及线程的源码分析==

一、线程的实现形式

继承Thread类，重写run办法
实现Runnable接口，重写run办法
实现Callable接口重写run办法，通过FutureTask包装器获取返回值

1.继承Thread类，重写run办法

/** * 多线程 *      继承 Thread形式 * @author zhaojun */public class MyThread extends Thread {    public MyThread(String name) {        // 反对自定义线程名称        super(name);    }    @Override    public void run() {        System.out.println(Thread.currentThread().getName() + " -> " + Thread.currentThread().getId());    }    /**     * 测试     */    public static void main(String[] args) {        new MyThread("thread_1").start();        new MyThread("thread_2").start();        System.out.println(Thread.currentThread().getName() + " -> " + Thread.currentThread().getId());    }}

测试后果如下：

2.实现Runnable接口，重写run办法

/** * 多线程 *      实现 Runnable形式 * @author zhaojun */public class MyRunnable implements Runnable {    @Override    public void run() {        System.out.println(Thread.currentThread().getName() + " -> " + Thread.currentThread().getId());    }    /**     * 测试     */    public static void main(String[] args) {        new Thread(new MyRunnable(), "runnable_1").start();        new Thread(new MyRunnable(), "runnable_2").start();        System.out.println(Thread.currentThread().getName() + " -> " + Thread.currentThread().getId());    }}

测试后果如下：

3.实现Callable接口重写run办法，通过FutureTask包装器获取返回值

/** * 多线程 *      实现 Callable形式, 利用 FutureTask获取返回值 * @author zhaojun */public class MyCallable implements Callable<String> {    // Callable接口反对指定泛型，对应call返回值类型为指定泛型    @Override    public String call() throws Exception {        System.out.println(Thread.currentThread().getName() + " -> " + Thread.currentThread().getId());        return Thread.currentThread().getName() + "线程以后运行状态为：" + Thread.currentThread().getState();    }    /**     * 测试     */    public static void main(String[] args) throws Exception {        FutureTask<String> task1 = new FutureTask<>(new MyCallable());        new Thread(task1, "callable_1").start();        System.out.println(task1.get());        FutureTask<String> task2 = new FutureTask<>(new MyCallable());        new Thread(task2, "callable_2").start();        System.out.println(task2.get());        System.out.println(Thread.currentThread().getName() + " -> " + Thread.currentThread().getId());    }}

测试后果如下：

二、线程的生命周期

线程初始状态：NEW
线程运行状态：RUNNABLE
线程阻塞状态：BLOCKED
线程期待状态：WAITING
超时期待状态：TIMED_WAITING
线程终止状态：TERMINATED

这并不是笔者胡乱假造的，而是jdk源码中定义的（Thread类中保护的一个枚举类），源码如下并加以翻译：

/** * 多线程 *      源码定义 - 翻译 * @author zhaojun */public enum State {    /**     * 线程初始状态     *      线程被构建，还未调用 start办法     */    NEW,    /**     * 线程运行状态     *      JAVA线程把操作系统中的（就绪和运行）两种状态对立称为 运行中     */    RUNNABLE,    /**     * 线程阻塞状态     *      示意线程进入期待状态，即线程因为某种原因放弃了 CPU使用权，阻塞也分为几种状况：     *       1.期待阻塞：运行的线程执行 wait办法，JVM会把以后线程放入到期待队列     *       2.同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被其余线程锁占用了，那么 JVM会把以后的线程放入到锁池中     *       3.其余阻塞：运行的线程执行 Thread.sleep或者 join办法，或者收回了 I/O申请时，     *                  JVM会把以后线程设置为阻塞状态，当 sleep完结/join线程终止、I/O处理完毕则线程复原     */    BLOCKED,    /**     * 线程期待状态     */    WAITING,    /**     * 线程超时期待状态     *      超时之后主动返回     */    TIMED_WAITING,    /**     * 线程终止状态     *      示意以后线程执行结束     */    TERMINATED;}

三、线程状态转换

此处重点讲下，线程状态如何变更为：
       1.TIME_WAITING：线程超时期待状态
       2.WAITING：线程期待状态
       3.BLOCKED：线程阻塞状态

/** * 多线程 *      状态转换 - 代码演示 * @author zhaojun */public class ThreadStatus {    public static void main(String[] args) {        /**         * Thread -> TIME_WAITING：线程超时期待状态         */        Thread timeWaiting = new Thread(() -> {            while (true) {                try {                    // sleep 99s                    TimeUnit.SECONDS.sleep(99);                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        }, "Time_Waiting_Thread");        /**         * Thread -> WAITING：线程期待状态         */        Thread waiting = new Thread(() -> {            while (true) {                synchronized (ThreadStatus.class) {                    try {                        // wait                        ThreadStatus.class.wait();                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                }            }        }, "Waiting_Thread");        /**         * Thread -> BLOCKED：线程阻塞状态         */        Thread blocked_thread_01 = new Thread(new BlockedThread(), "Blocked_Thread_01");        Thread blocked_thread_02 = new Thread(new BlockedThread(), "Blocked_Thread_02");        /**         * 启动         */        timeWaiting.start();        waiting.start();        blocked_thread_01.start();        blocked_thread_02.start();    }    /**     * 定义阻塞线程类     */    static class BlockedThread extends Thread {        @Override        public void run() {            synchronized (BlockedThread.class) {                while (true) {                    try {                        TimeUnit.SECONDS.sleep(99);                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                }            }        }    }}

测试后果如下：

首先运行main办法，在以后测试类任意地位右击，点击Open in Terminal：

输出jps -l命令，查看所有java过程对应pid，查找ThreadStatus对应 pid：

输出 jstack pid命令，查看其堆栈信息：

从上图中，能够很清晰的看出：
线程Waiting_Thread 通过 wait();，状态 ==->== 期待状态；
线程Time_Waiting_Thread 通过sleep()，状态 ==->== 超时期待状态；
线程Blocked_Thread_01先取得锁，而后通过sleep()，状态 ==->== 超时期待状态；
线程Blocked_Thread_02未取得锁，状态 ==->== 阻塞状态；

四、线程的启动

经典面试题

为什么启动一个线程调用 start办法，而不是run办法呢？

源码分析

接下来，带大家来看一下 start()办法，在源码中如何定义的：

    public synchronized void start() {        if (threadStatus != 0)            throw new IllegalThreadStateException();        /* Notify the group that this thread is about to be started         * so that it can be added to the group's list of threads         * and the group's unstarted count can be decremented. */        group.add(this);        boolean started = false;        try {                                   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(); // -.- 眼光会聚这里

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

咱们发现 start()实际上调用了 start0()来启动线程，而且 start0()是由native润饰的本地办法
这里先记住，start0()这个办法是在 Thread 的动态块中来注册的。

到这里，我须要给各位开发小伙伴科普一个文件 Thread.c
该文件定义了各个操作系统平台要用的对于线程的公共数据以及操作，代码如下：

#include "jni.h"#include "jvm.h"#include "java_lang_Thread.h"#define THD "Ljava/lang/Thread;"#define OBJ "Ljava/lang/Object;"#define STE "Ljava/lang/StackTraceElement;"#define ARRAY_LENGTH(a) (sizeof(a)/sizeof(a[0]))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},};#undef THD#undef OBJ#undef STEJNIEXPORT void JNICALLJava_java_lang_Thread_registerNatives(JNIEnv *env, jclass cls) // 发现 registerNatives()办法定义在这里{    (*env)->RegisterNatives(env, cls, methods, ARRAY_LENGTH(methods));}

从代码中看到，start0()会执行JVM_StartThread这个办法，那么问题来了，JVM_StartThread又是什么呢？俗话说，码如其名，先从名字推断应该是在 JVM层启动一个线程，既然有了猜测，咱们无妨去验证下。

==留神：这里须要下载 hotspot的源码，它是JVM的具体实现，有趣味的小伙伴能够自行下载==

不过，大家莫慌，针对线程启动的源码我会附上
咱们找到 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);...

从代码中能够看出，JVM_ENTRY用来定义JVM_StartThread函数的，在这个函数中创立了一个真正的和平台无关的本地线程，之后new了一个javaThread，看看其具体做了什么：

再找到 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);  _safepoint_visible = false;}

此函数有两个参数：

1.函数名称，线程创立胜利之后依据函数名称调用对应函数；

2.以后过程内已有的线程数量<br/>
在上述代码19行，os::create_thread，是调用平台创立线程的办法从而来进行创立线程，接下来就是线程的启动了，代码如下：

void Thread::start(Thread* thread) {  trace("start", thread);  // Start is different from resume in that its safety is guaranteed by context or  // being called from a Java method synchronized on the Thread object.  if (!DisableStartThread) {    if (thread->is_Java_thread()) {      // Initialize the thread state to RUNNABLE before starting this thread.      // Can not set it after the thread started because we do not know the      // exact thread state at that time. It could be in MONITOR_WAIT or      // in SLEEPING or some other state.      java_lang_Thread::set_thread_status(((JavaThread*)thread)->threadObj(),                                          java_lang_Thread::RUNNABLE);    }    os::start_thread(thread);  }}

上述代码14行，os::start_thread(thread)就是平台启动线程的办法，最终会调用 Thread.cpp文件中的 JavaThread::run()办法，至此，一个线程的启动就实现了。

五、线程的终止

暴力终止法：stop()
自定义标记位终止
优雅中断法：interrupt()

1.暴力终止法：stop()

如图所示，官网已将 stop()定义为过期办法，并不倡议应用；
stop()办法在完结一个线程时并不会保障线程的资源失常释放，因而会导致程序可能呈现一些不确定的状态。

在JDK官网文档中定义弃用这些办法的起因，链接如下：
Why Are Thread.stop, Thread.suspend, Thread.resume and Runtime.runFinalizersOnExit Deprecated?
<br/>

2.自定义标记位终止

首先咱们晓得，一个线程完结与否取决于以后线程的 run()办法是否执行结束，咱们可自定义标记位来控制线程的完结，代码如下：

/** * 多线程 *      线程终止：自定义标记位 */public class ThreadFlagDemo extends Thread {    // 标记位    private volatile boolean isFinish = false;    private static int i;    @Override    public void run() {        while (!isFinish) {            i++;        }        System.out.println("i:"+i);    }    /**     * 测试     */    public static void main(String[] args) throws InterruptedException {        ThreadFlagDemo thread = new ThreadFlagDemo();        thread.start();        Thread.sleep(1000);        // 变更标记位，完结线程        thread.isFinish = true;    }}

如代码所示，咱们能够通过自定义一个标记位，来完结死循环以致run()完结，从而来控制线程的完结。

3.优雅中断法：interrupt()

这里需明确一点，调用 interrupt() 办法，示意向以后线程打个招呼，通知其能够中断线程了，至于什么时候终止，取决于以后线程本人，其实原理跟自定义标记位类似，只是打一个进行的标记，并不会去真的进行线程。

/** * 多线程 *      线程终止：interrupt()办法 */public class ThreadInterruptDemo {    private static int i;    /**     * 测试     */    public static void main(String[] args) throws InterruptedException {        Thread thread = new Thread(() -> {            // isInterrupted()默认为false            while (!Thread.currentThread().isInterrupted()) {                i++;            }            System.out.println("i:"+i);        });        thread.start();        TimeUnit.SECONDS.sleep(1);        // 将isInterrupted()设置为true        thread.interrupt();    }}

这种通过标记位或中断操作的形式可能使线程在终止时能够继续执行外部逻辑，而不是立刻进行线程，所以，这种中断线程的形式更加的优雅平安，举荐此种形式。

六、线程的复位

Thread.interrupted()
通过抛出InterruptedException异样

1.Thread.interrupted()

/** * 多线程 *      线程复位：Thread.interrupted()办法 */public class ThreadInterruptedReset {    /**     * 测试     */    public static void main(String[] args) throws InterruptedException {        Thread thread = new Thread(() -> {            String threadName = Thread.currentThread().getName();            while (true) {                if(Thread.currentThread().isInterrupted()) {                    System.out.println(threadName + "：before -> " + Thread.currentThread().isInterrupted());                    // 线程复位                    Thread.interrupted();                    System.out.println(threadName + "：after -> " + Thread.currentThread().isInterrupted());                    break; // 完结                }            }        }, "Thread_Interrupted");        thread.start();        TimeUnit.SECONDS.sleep(1);        // 将isInterrupted()设置为true        thread.interrupt();    }}

执行流程如下：<br/>

执行main()办法，标识"main"主线程启动，代码自上而下执行
"Thread_Interrupted"线程启动，while循环开启，isInterrupted()默认false，...以后处在死循环中；
与此同时，"main"主线程sleep 1s完结后，将 isInterrupted()设置为true；
此时，"Thread_Interrupted"线程中，因为 isInterrupted()以后被设置为true，执行 if块代码，before -> true;
通过 Thread.interrupted()进行复位，after -> false，最终执行 break，完结循环完结线程。

执行流程如下：

2.通过抛出InterruptedException异样

/** * 多线程 *      线程复位：InterruptedException异样 */public class ThreadExeptionReset {    /**     * 测试     */    public static void main(String[] args) throws InterruptedException {        Thread thread = new Thread(() -> {            String threadName = Thread.currentThread().getName();            while (true) {                if(Thread.currentThread().isInterrupted()) {                    try {                        System.out.println(threadName + "：before -> " + Thread.currentThread().isInterrupted());                        TimeUnit.SECONDS.sleep(10);                    } catch (InterruptedException e) {                        System.out.println(threadName + "：after -> " + Thread.currentThread().isInterrupted());                        e.printStackTrace();                        break; // 完结                    }                }            }        }, "Thread_InterruptedException");        thread.start();        TimeUnit.SECONDS.sleep(1);        // 将isInterrupted()设置为true        thread.interrupt();    }}

执行流程如下：

执行main()办法，标识"main"主线程启动，代码自上而下执行
"Thread_InterruptedException"线程启动，while循环开启，isInterrupted()默认false，...以后处在死循环中；
与此同时，"main"主线程sleep 1s完结后，将 isInterrupted()设置为true；
此时，"Thread_InterruptedException"线程中，因为 isInterrupted()以后被设置为true，执行 if块代码，before -> true;
接着执行sleep()，抛出InterruptedException异样进行复位，after -> false，最终执行 break，完结循环完结线程。

执行流程如下：

福利：梁博-《呈现又来到》

今日举荐单曲，梁博学生的《呈现又来到》，放松情绪，努力学习~

差点遗记件比写博客还要重要的事件 ~
这里有博哥（梁博）的粉丝么，据说往年有博哥的演唱会，私信我，约起哈 ~ ❤