异常与多线程

Posted 2020-12-10 lf-637

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了异常与多线程相关的知识，希望对你有一定的参考价值。

一、异常

1. 概述

异常：指的是程序在执行过程中，出现的非正常的情况，最终导致JVM虚拟机的非正常停止

在Java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建异常对象并抛出了一个异常对象。Java处理异常的方式是中断处理

异常指的并不是语法错误，语法错了，编译不通过，不会产生字节码文件,根本不能运行

2. 异常体系

异常机制其实是帮助我们找到程序中的问题，Java把异常当作对象来处理，并定义一个基类 java.lang.Throwable 作为所有异常的超类。

Throwable中的常用方法：
public void printStackTrace():打印异常的详细信息。
		包含了异常的类型,异常的原因,还包括异常出现的位置,在开发和调试阶段,都得使用printStackTrace

public String getMessage()`:获取发生异常的原因
		提示给用户的时候,就提示错误原因

出现异常,不要紧张,把异常的简单类名,拷贝到API中去查。

在Java API中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception

Exception：用户程序可能捕捉的异常情况或者说是程序可以处理的异常
- 编译期异常，进行编译(写代码)java程序出现的问题
- RuntimeException：运行期异常，java程序运行过程中出现的问题
- 异常就相当于程序得了一个小毛病。异常处理好，程序可以继续执行
Error：不希望被程序捕获或者是程序无法处理的错误
- 错误就相当于程序得了大病，必须修改源代码,程序才能继续执行

Java异常层次结构图：

技术图片

从图中可以看出所有异常类型都是内置类Throwable的子类，因而 Throwable 在异常类的层次结构的顶层。

异常类 Exception 又分为运行时异常( RuntimeException )和非运行时异常。

3. 异常之间的区别与联系

Error

Error 类对象由 Java 虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关。
比如说：

Java虚拟机运行错误，当JVM不再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError 。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止
还有发生在虚拟机试图执行应用时，如类定义错误（ NoClassDefFoundError ）、链接错误（ LinkageError ）。这些错误是不可查的，因为它们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的状况。

对于设计合理的应用程序来说，即使确实发生了错误，本质上也不应该试图去处理它所引起的异常状况。在Java中，错误通常是使用 Error 的子类描述

Exception

在 Exception 分支中有一个重要的子类 RuntimeException （运行时异常），该类型的异常自动为编写的程序定义如：

ArrayIndexOutOfBoundsException （数组下标越界）、NullPointerException （空指针异常）ArithmeticException （算术异常）、 MissingResourceException （丢失资源）、ClassNotFoundException （找不到类）

等异常，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。此异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生；

而RuntimeException 之外的异常我们统称为非运行时异常，类型上属于Exception 类及其子类，从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。如IOException 、 SQLException 等以及用户自定义的 Exception 异常，一般情况下不自定义检查异常。
Error 和 Exception 的区别：

Error 通常是灾难性的致命的错误，是程序无法控制和处理的，当出现这些异常时，Java虚拟机（JVM）一般会选择终止线程
Exception 通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常

4. Java异常处理机制

java异常处理本质：抛出异常和捕获异常

抛出异常

要理解抛出异常

首先要明白什么是异常情形，它是指阻止当前方法或作用域继续执行的问题
其次把异常情形和普通问题相区分
- 普通问题是指在当前环境下能得到足够的信息，总能处理这个错误。
- 对于异常情形，已经无法继续下去了，因为在当前环境下无法获得必要的信息来解决问题，你所能做的就是从当前环境中跳出，并把问题提交给上一级环境，这就是抛出异常时所发生的事情
抛出异常后，会有几件事随之发生。
- 首先，是像创建普通的java对象一样将使用 new 在堆上创建一个异常对象
- 然后，当前的执行路径（已经无法继续下去了）被终止，并且从当前环境中弹出对异常对象的引用
- 此时异常处理机制接管程序，并开始寻找一个恰当的地方继续执行程序，这个恰当的地方就是异常处理程序或者异常处理器，它的任务是将程序从错误状态中恢复，以使程序要么换一种方式运行，要么继续运行下去

捕获异常

在方法抛出异常之后，运行时系统将转为寻找合适的异常处理器。潜在的异常处理器是异常发生时依次存留在调用栈中的方法的集合。当异常处理器所能处理的异常类型与方法抛出的异常类型相符时，即为合适的异常处理器。运行时系统从发生异常的方法开始，依次回查调用栈中的方法，直至找到含有合适异常处理器的方法并执行。当运行时系统遍历调用栈而未找到合适的异常处理器，则运行时系统终止。同时，意味着Java程序的终止

注意：

对于运行时异常、错误和检查异常，Java技术所要求的异常处理方式有所不同
由于运行时异常及其子类的不可查性，为了更合理、更容易地实现应用程序，Java规定，运行时异常将由Java运行时系统自动抛出，允许应用程序忽略运行时异常。
对于方法运行中可能出现的 Error ，当运行方法不欲捕捉时，Java允许该方法不做任何抛出声明。因为，大多数 Error 异常属于永远不能被允许发生的状况，也属于合理的应用程序不该捕捉的异常

对于所有的检查异常，Java规定：一个方法必须捕捉，或者声明抛出方法之外。也就是说，当一个方法选择不捕捉检查异常时，它必须声明将抛出异常

二、异常的处理

Java异常处理的五个关键字：try、catch、finally、throw、throws

1. throw关键字

作用：

在java中提供了一个throw关键字，它用来抛出一个指定的异常对象。

格式：

throw new xxxException("异常产生的原因");

例如：

throw new NullPointerException("要访问的arr数组不存在");

throw new ArrayIndexOutOfBoundsException("该索引在数组中不存在，已超出范围");

注意：

throw关键字必须写在方法的内部
throw关键字后边new的对象必须是Exception或者Exception的子类对象
throw关键字抛出指定的异常对象,我们就必须处理这个异常对象
- throw关键字后边创建的是RuntimeException或者是 RuntimeException的子类对象,我们可以不处理,默认交给JVM处理(打印异常对象,中断程序)
- throw关键字后边创建的是编译异常(写代码的时候报错),我们就必须处理这个异常,要么throws,要么try...catch
以后我们首先必须对方法传递过来的参数进行合法性校验
- 若参数不合法，就必须使用抛出异常的方式告知方法的调用者，床底的参数有问题

下面是一个例子：

public class Demo03Throw {
    public static void main(String[] args) {
        //int[] arr = null;
        int[] arr = new int[3];
        int e = getElement(arr,3);
        System.out.println(e);
    }
    /*
        定义一个方法,获取数组指定索引处的元素
        参数:
            int[] arr
            int index
        注意:
            NullPointerException是一个运行期异常,我们不用处理,默认交给JVM处理
            ArrayIndexOutOfBoundsException是一个运行期异常,我们不用处理,默认交给JVM处理
     */
    public static int getElement(int[] arr,int index){
        /*
            对传递过来的参数数组,进行合法性校验
            如果数组arr的值是null
            那么我们就抛出空指针异常,告知方法的调用者"传递的数组的值是null"
         */
        if(arr == null){
            throw new NullPointerException("传递的数组的值是null");
        }

        /*
            对传递过来的参数index进行合法性校验
            如果index的范围不在数组的索引范围内
            那么我们就抛出数组索引越界异常,告知方法的调用者"传递的索引超出了数组的使用范围"
         */
        if(index<0 || index>arr.length-1){
            throw new ArrayIndexOutOfBoundsException("传递的索引超出了数组的使用范围");
        }

        int ele = arr[index];
        return ele;
    }
}

注意：如果产生了问题，我们就会throw将问题描述类即异常进行抛出，也就是将问题返回给该方法的调用者。

那么对于调用者来说，该怎么处理呢？一种是进行捕获处理，另一种就是继续将问题声明出去，使用throws声明处理。

2. Objects非空判断

我们学习过一个类Objects，它由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的）。在它的源码中，对对象为null的值进行了抛出异常操作。

public static <T> T requireNonNull(T obj):查看指定引用对象不是null。

查看源码发现这里对为null的进行了抛出异常操作：

public static <T> T requireNonNull(T obj) {
    if (obj == null)
      	throw new NullPointerException();
    return obj;
}

2.3 声明异常throws

throws关键字：异常处理的第一种方式,交给别人处理

关键字throws运用于方法声明之上，用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常).

作用：

当方法内部抛出异常对象的时候,那么我们就必须处理这个异常对象
可以使用throws关键字处理异常对象,会把异常对象声明抛出给方法的调用者处理(自己不处理,给别人处理),最终交给JVM处理-->中断处理

使用格式：在方法声明时使用

修饰符 返回值类型 方法名(参数列表) throws AAAExcepiton,BBBExcepiton...{
            throw new AAAExcepiton("产生原因");
            throw new BBBExcepiton("产生原因");
            ...
        }

注意:

throws关键字必须写在方法声明处
throws关键字后边声明的异常必须是Exception或者是Exception的子类
方法内部如果抛出了多个异常对象,那么throws后边必须也声明多个异常
- 如果抛出的多个异常对象有子父类关系,那么直接声明父类异常即可
调用了一个声明抛出异常的方法,我们就必须的处理声明的异常
- 要么继续使用throws声明抛出,交给方法的调用者处理,最终交给JVM
- 要么try...catch自己处理异常声明异常

throws用于进行异常类的声明，若该方法可能有多种异常情况产生，那么在throws后面可以写多个异常类，用逗号隔开。

public class Demo05Throws {
    /*
        FileNotFoundException extends IOException extends Excepiton
        如果抛出的多个异常对象有子父类关系,那么直接声明父类异常即可
     */
    public static void main(String[] args) throws Exception {
        readFile("c:\\a.tx");
        System.out.println("后续代码");
    }
    /*
        定义一个方法,对传递的文件路径进行合法性判断
        如果路径不是"c:\\a.txt",那么我们就抛出文件找不到异常对象,告知方法的调用者
        注意:
            FileNotFoundException是编译异常,抛出了编译异常,就必须处理这个异常
            可以使用throws继续声明抛出FileNotFoundException这个异常对象,让方法的调用者处理
     */
    public static void readFile(String fileName) throws FileNotFoundException,IOException{
        if(!fileName.equals("c:\\a.txt")){
            throw new FileNotFoundException("传递的文件路径不是c:\\a.txt");
        }
        /*
            如果传递的路径,不是.txt结尾
            那么我们就抛出IO异常对象,告知方法的调用者,文件的后缀名不对
         */
        if(!fileName.endsWith(".txt")){
            throw new IOException("文件的后缀名不对");
        }
        System.out.println("路径没有问题,读取文件");
    }
}

4. 捕获异常try…catch

如果出现异常立刻终止程序，所以我们需要处理异常：

该方法不处理,而是声明抛出,由该方法的调用者来处理(throws)。
在方法中使用try-catch的语句块来处理异常。

try-catch的方式就是捕获异常，是异常处理的第二种方式，自己处理异常

捕获异常：Java中对异常有针对性的语句进行捕获，可以对出现的异常进行指定方式的处理。

格式：

try{
     编写可能会出现异常的代码
}catch(异常类型  e){
     处理异常的代码
     //记录日志/打印异常信息/继续抛出异常
}
//try：该代码块中编写可能产生异常的代码。
//catch：用来进行某种异常的捕获，实现对捕获到的异常进行处理。

注意：

try中可能会抛出多个异常对象，那么就可以使用多个catch来处理这些异常对象
如果try中产生了异常,那么就会执行catch中的异常处理逻辑，执行完毕catch中的处理逻辑,继续执行try...catch之后的代码
如果try中没有产生异常，那么就不会执行catch中异常的处理逻辑,执行完try中的代码，继续执行try...catch之后的代码
try和catch都不能单独使用,必须连用

演示如下：

public class Demo01TryCatch {
    public static void main(String[] args) {
        try{
            //可能产生异常的代码
            readFile("d:\\a.tx");
            System.out.println("资源释放");
        }catch (IOException e){//try中抛出什么异常对象,catch就定义什么异常变量,用来接收这个异常对象
            //异常的处理逻辑,异常异常对象之后,怎么处理异常对象
            //System.out.println("catch - 传递的文件后缀不是.txt");

            //System.out.println(e.getMessage());//文件的后缀名不对
            //System.out.println(e.toString());//重写Object类的toString java.io.IOException: 文件的后缀名不对
            //System.out.println(e);//java.io.IOException: 文件的后缀名不对 
            e.printStackTrace();
        }
        System.out.println("后续代码");
    }
    /*
       如果传递的路径,不是.txt结尾
       那么我们就抛出IO异常对象,告知方法的调用者,文件的后缀名不对
    */
    public static void readFile(String fileName) throws IOException {
        if(!fileName.endsWith(".txt")){
            throw new IOException("文件的后缀名不对");
        }
        System.out.println("路径没有问题,读取文件");
    }
}

如何获取异常信息：

Throwable类中定义了一些查看方法

public String getMessage()，获取异常的描述信息、原因提示给用户，即返回此异常的简短描述
public String toString()，重写Object类的toString方法，获取异常的类型和异常描述信息
public void printStackTrace()，JVM打印异常对象,默认此方法,打印的异常信息是最全面的

? 包含了异常的类型,异常的原因,还包括异常出现的位置,在开发和调试阶段,都得使用printStackTrace。

5. finally 代码块

finally：有一些特定的代码无论异常是否发生都需要执行，若因为异常，会引发程序跳转导致有些语句执行不到。而finally就是解决这个问题，在finally代码块中存放的代码都是一定会被执行的。

什么时候的代码必须最终执行？

当我们在try语句块中打开了一些物理资源(磁盘文件/网络连接/数据库连接等),我们都得在使用完之后,最终关闭打开的资源。

格式：

try{
            可能产生异常的代码
        }catch(定义一个异常的变量,用来接收try中抛出的异常对象){
            异常的处理逻辑,异常异常对象之后,怎么处理异常对象
            一般在工作中,会把异常的信息记录到一个日志中
        }
        ...
        catch(异常类名 变量名){

        }finally{
            无论是否出现异常都会执行
}

注意：

finally不能单独使用，必须和try一起使用
finally一般用于资源释放(资源回收)，无论程序是否出现异常,最后都要资源释放(IO)
如果finally中有return语句程序永远返回finally中的结果。需避免这种情况发生。不要在final语句中使用return

比如在我们之后学习的IO流中，当打开了一个关联文件的资源，最后程序不管结果如何，都需要把这个资源关闭掉。

finally代码参考如下：

public class Demo02TryCatchFinally {
    public static void main(String[] args) {
        try {
            //可能会产生异常的代码
            readFile("c:\\a.tx");
        } catch (IOException e) {
            //异常的处理逻辑
            e.printStackTrace();
        } finally {
            //无论是否出现异常,都会执行
            System.out.println("资源释放");
        }
    }

    /*
       如果传递的路径,不是.txt结尾
       那么我们就抛出IO异常对象,告知方法的调用者,文件的后缀名不对

    */
    public static void readFile(String fileName) throws IOException {

        if(!fileName.endsWith(".txt")){
            throw new IOException("文件的后缀名不对");
        }

        System.out.println("路径没有问题,读取文件");
    }
}

只有在try或者catch中调用退出JVM的相关方法，finally才不会执行，否则会永远执行

6. 异常注意事项

多个异常使用捕获处理方法如下
1. 多个异常分别处理。
2. 多个异常一次捕获，多次处理。
3. 多个异常一次捕获一次处理。
一般是使用一次捕获多次处理方式，格式如下：
```
try{
     编写可能会出现异常的代码
}catch(异常类型A  e){  当try中出现A类型异常,就用该catch来捕获.
     处理异常的代码
     //记录日志/打印异常信息/继续抛出异常
}catch(异常类型B  e){  当try中出现B类型异常,就用该catch来捕获.
     处理异常的代码
     //记录日志/打印异常信息/继续抛出异常
}
```
注意：这种异常处理方式，要求多个catch中的异常不能相同，并且若catch中的多个异常之间有子父类异常的关系，那么子类异常要求在上面的catch处理，父类异常在下面的catch处理。
运行时异常被抛出可以不处理。即不捕获也不声明抛出。
如果finally有return语句,永远返回finally中的结果,避免该情况.

子父类异常

如果父类抛出了多个异常，子类重写父类方法时有三种情况
- 抛出和父类相同的异常
- 抛出父类异常的子类
- 不抛出异常
父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常
- 此时子类产生该异常，只能捕获处理，不能声明抛出

注意：

父类异常时什么样，子类异常就什么样

三、自定义异常

1. 概述

Java中有很多种异常类，分别表示某一种具体的异常情况。但实际中总是有些异常情况是没有定义好的，此时我们可以根据遇到的的异常情况来定义异常类。例如年龄负数问题,考试成绩负数问题等等。

定义：

java提供的异常类不够我们使用，需要自己定义一些异常类
自定义一个编译期异常: 自定义类并继承于java.lang.Exception。
自定义一个运行时期的异常类:自定义类并继承于java.lang.RuntimeException

格式：

public class XXXExcepiton extends Exception | RuntimeException{
            添加一个空参数的构造方法
            添加一个带异常信息的构造方法
}

注意：

自定义异常类一般都是以Exception结尾，说明该类是一个异常类
自定义异常类,必须的继承Exception或者RuntimeException
- 继承Exception：那么自定义的异常类就是一个编译期异常，如果方法内部抛出了编译期异常,就必须处理这个异常,要么throws，要么try...catch
- 继承RuntimeException：那么自定义的异常类就是一个运行期异常,无需处理，交给虚拟机处理(中断处理)

例子：

要求：模拟注册操作，如果用户名已存在，则抛出异常并提示：该用户名已经被注册

分析:

使用数组保存已经注册过的用户名(数据库)
使用Scanner获取用户输入的注册的用户名(前端,页面)
定义一个方法,对用户输入的中注册的用户名进行判断
- 遍历存储已经注册过用户名的数组,获取每一个用户名
- 使用获取到的用户名和用户输入的用户名比较
  - true:
    - 用户名已经存在,抛出RegisterException异常，告知用户"该用户名已经被注册";
  - false:
    - 继续遍历比较
    - 如果循环结束了，还没有找到重复的用户名，提示用户"恭喜您,注册成功!";

public class RegisterException {
    // 1.使用数组保存已经注册过的用户名(数据库)
    static String[] usernames = {"张三","李四","王五"};

    public static void main(String[] args) /*throws RegisterException*/ {
        //2.使用Scanner获取用户输入的注册的用户名(前端,页面)
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您要注册的用户名:");
        String username = sc.next();
        checkUsername(username);

    }
        //3.定义一个方法,对用户输入的中注册的用户名进行判断
    public static void checkUsername(String username) /*throws RegisterException*/ {
        //遍历存储已经注册过用户名的数组,获取每一个用户名
        for (String name : usernames) {
            //使用获取到的用户名和用户输入的用户名比较
            if(name.equals(username)){
                //true:用户名已经存在,抛出RegisterException异常,告知用户"该用户名已经被注册";
                try {
                    throw new RegisterException("该用户名已经被注册");
                } catch (RegisterException e) {
                    e.printStackTrace();
                    return; //结束方法
                }
            }
        }

        //如果循环结束了,还没有找到重复的用户名,提示用户"恭喜您,注册成功!";
        System.out.println("恭喜您,注册成功!");
    }
}

第四章多线程

Java给多线程编程提供了内置的支持。一个多线程程序包含两个或多个能并发运行的部分。程序的每一部分都称作一个线程，并且每个线程定义了一个独立的执行路径。

多线程能满足程序员编写非常有效率的程序来达到充分利用CPU的目的，因为CPU的空闲时间能够保持在最低限度。

1. 并发与并行

并发：指两个或多个事件在同一个时间段内发生。
并行：指两个或多个事件在同一时刻发生（同时发生）。

注意：单核处理器的计算机肯定是不能并行的处理多个任务的，只能是多个任务在单个CPU上并发运行。同理，线程也是一样的，从宏观角度上理解线程是并行运行的，但是从微观角度上分析却是串行运行的，即一个线程一个线程的去运行，当系统只有一个CPU时，线程会以某种顺序执行多个线程，我们把这种情况称之为线程调度。

2. 线程与进程

进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行。
- 一个线程不能独立的存在，它必须是进程的一部分
- 一个进程中是可以有多个线程的，这个应用程序也称之为多线程程序。
- 一个程序运行后至少有一个进程，一个进程中可以包含多个线程

线程调度:

分时调度

所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。
抢占式调度

优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。

3. 创建线程类

Java提供了三种创建线程方法：

通过实现Runnable接口
通过继承Thread类本身
通过 Callable 和 Future 创建线程

创建多线程程序的第一种方式：创建Thread类的子类

Java使用java.lang.Thread是描述线程的类，所有的线程对象都必须是Thread类或其子类的实例。我们想要实现多线程程序,就必须继承Thread类

实现步骤：

创建一个Thread类的子类
在Thread类的子类中重写Thread类中的run方法,设置线程任务(开启线程要做什么?)
创建Thread类的子类对象
用Thread类中的方法start方法,开启新的线程,执行run方法
- void start() 使该线程开始执行；Java 虚拟机调用该线程的 run 方法
- 结果是两个线程并发地运行；当前线程（main线程）和另一个线程（创建的新线程,执行其 run 方法）
- 多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启动

java程序属于抢占式调度,那个线程的优先级高,那个线程优先执行;同一个优先级,随机选择一个执行

代码如下：

测试类：

public class Demo01Thread {
    public static void main(String[] args) {
        //3.创建Thread类的子类对象
        MyThread mt = new MyThread();
        //4.调用Thread类中的方法start方法,开启新的线程,执行run方法
        mt.start();

        for (int i = 0; i <20 ; i++) {
            System.out.println("main:"+i);
        }
    }
}

自定义线程类：

//1.创建一个Thread类的子类
public class MyThread extends Thread{
    //2.在Thread类的子类中重写Thread类中的run方法,设置线程任务(开启线程要做什么?)
    @Override
    public void run() {
        for (int i = 0; i <20 ; i++) {
            System.out.println("run:"+i);
        }
    }
}

以上是关于异常与多线程的主要内容，如果未能解决你的问题，请参考以下文章

阶段1 语言基础+高级_1-3-Java语言高级_05-异常与多线程_第5节线程池_2_线程池的代码实现

异常与多线程

阶段1 语言基础+高级_1-3-Java语言高级_05-异常与多线程_第3节线程同步机制_3_线程安全问题产生的原理

阶段1 语言基础+高级_1-3-Java语言高级_05-异常与多线程_第4节等待唤醒机制_8_等待唤醒机制代码实现_包子类&包子铺类

阶段1 语言基础+高级_1-3-Java语言高级_05-异常与多线程_第1节异常_3_异常的产生过程解析

异常与多线程

一、异常

1. 概述

2. 异常体系

3. 异常之间的区别与联系

Error

Exception

4. Java异常处理机制

抛出异常

捕获异常

二、异常的处理

1. throw关键字

2. Objects非空判断

2.3 声明异常throws

4. 捕获异常try…catch

5. finally 代码块

6. 异常注意事项

子父类异常

三、自定义异常

1. 概述

第四章 多线程

1. 并发与并行

2. 线程与进程

3. 创建线程类

创建多线程程序的第一种方式：创建Thread类的子类

第四章多线程