线程/进程/协程的区别以及多线程状态/多线程的统一异常处理

从本章开始，探究多线程的奥秘，一起进入多线程的世界！

1.线程、进程、协程区别

(图1-1)
线程：线程从属于进程，是程序的实际执行者，一个进程包含至少一个线程，线程拥有自己的栈空间。
进程：进程是应用启动的实例，进程能够拥有代码和打开的文件资源、数据资源、独立的内存空间。
进程与线程区别：进程是cpu资源分配的基本单位，线程是独立运行和独立调度的基本单位；进程有独立的资源空间，一个进程包含多个线程，线程与cpu无关，多个线程共享同一进程内的资源；线程的调度与切换比进程调度更快。
协程：协程是一个特殊函数，由程序执行所控制，一个线程包含多个协程，并且协程是串行执行的。

2.并发与并行

并发：同时触发，但只能有一个进行，其余等待完成后再进行。
并行：同时触发，同时进行。

3.线程状态的转换

线程的状态：创建、可运行、运行中、阻塞、销毁(图1-2)。
线程的状态官方说的是只有四种(创建、可运行、阻塞、销毁)，但我认为即使是处于可运行中，但没有cpu执行权，那也不算正在运行，所以我自己加了一个运行中状态，用于区分。

(图1-2)

4.多线程的统一异常处理

①. 可以使用thread.setUnCatchExpectionHandler设置手动处理未捕获的异常。
②. 可以使用Thread.setDefaultUnCatchExpectionHandler设置手动处理全局未捕获的异常
原理：当线程结束时(不管是正常结束还是异常结束)都会从C源码回调Thread的dispatchUncaughtException方法，如果自身设置了未捕获的手动异常处理，则执行自身设置的，如果没有，则递归查询父线程组中设置的未捕获的手动设置异常处理，如果父线程组都没有，则获取设置的全局的未捕获异常处理，如果也没有，则直接控制台输出。
下面代码演示统一异常处理的优先级：

/**
 * 对于线程中的异常，可以使用try catch进行异常捕获，但无法真正抛出；或无法捕获try catch之外的异常
 * 使用setUncaughtExceptionHandler方法，可以获取在线程执行中未捕获的异常进行统一处理  1优先级
 * 使用setDefaultUncaughtExceptionHandler方法 可以获取全部线程在执行中未捕获的异常进行统一处理 2优先级
 * 

 * 如果使用了同时使用setUncaughtExceptionHandler和setDefaultUncaughtExceptionHandler，则只在setUncaughtExceptionHandler中执行
 * 

 * 原理：在C源码层面，无论线程正常退出还是异常退出时，会检查是否是有异常，有则回调Thread.dispatchUncaughtException方法进行异常处理
 * 首先会检查自身线程有没有设置手动异常处理，如果没有则会在父线程组中去寻找：进行递归调用父线程有没有设置手动异常处理，如果也没有则否
 * 获取全局手动异常处理，如果有则执行，没有则直接控制台输出异常信息
 * 测试线程未捕获异常执行的真正优先级序列
 *
 * 1优先级：创建线程时覆盖getUnCatchExceptionHandler 的异常处理
 * 2优先级：使用该线程 setUnCatchExceptionHandler方法的手动异常处理
 * 3优先级：父线程组中的uncaughtException方法的手动异常处理
 * 4优先级：全局设置的异常处理
 * 都没有 控制台直接输出该异常
 */
public class TestThreadExceptionCatchPriority {

    public static void main(String[] args) {

        ThreadGroup group1 = new ThreadGroup("group1") /*{
            @Override//3优先级
            public void uncaughtException(Thread t, Throwable e) {
                System.out.println(Thread.currentThread().getThreadGroup().getName() + "," + t.getName() + ": " + e.getMessage());
            }
        }*/;
        ThreadGroup group2 = new ThreadGroup(group1, "group2");


        Thread thread1 = new Thread(group2,new Runnable() {
            @Override
            public void run() {
                System.out.println("thread1 is running!");
                int i = 1 / 0;
            }
        }, "thread1"){
            /*@Override//真正1优先级
            public UncaughtExceptionHandler getUncaughtExceptionHandler() {
                return new UncaughtExceptionHandler() {
                    @Override
                    public void uncaughtException(Thread t, Throwable e) {
                        System.out.println("first " + Thread.currentThread().getName() + ":" + e.getMessage());
                    }
                };
            }*/
        };

        //2优先级
        /*thread1.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
            @Override
            public void uncaughtException(Thread t, Throwable e) {
                System.out.println("special " + Thread.currentThread().getName() + ":" + e.getMessage());
            }
        });*/

        //4优先级
        /*Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
            @Override
            public void uncaughtException(Thread t, Throwable e) {
                System.out.println("common " + Thread.currentThread().getName() + ":" + e.getMessage());
            }
        });*/


        //5 都没有设置手动异常处理 直接控制台输出


        //启动
        thread1.start();
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

总结：
①. 进程是cpu资源分配的基础单位，能有独立的内存空间、可以打开文件资源、数据资源等；线程是独立运行和独立调度的基本单位，一个进程包含多个线程，多个线程内共享同一进程内的资源，并且调度比进程快；协程是一个特殊函数，并且是串行执行的，一个进程包含多个协程；目前写成没有官方类库，可以使用第三方类库(quasar)。
②. 线程的状态在运行中是不断进行转换的。
③. 在线程的异常处理中，有多种优先级的异常处理方式，根据需要进行使用。
好了多线程的基础知识就先总结到这里，欢迎大家阅读。