Chapter17 【异常、线程】

异常

1.1 异常概念

异常，就是不正常的意思。在生活中:医生说,你的身体某个部位有异常,该部位和正常相比有点不同,该部位的功能将受影响.在程序中的意思就是：

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

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

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

1.2 异常体系

异常机制其实是帮助我们找到程序中的问题，异常的根类是java.lang.Throwable，其下有两个子类：java.lang.Error与java.lang.Exception，平常所说的异常指java.lang.Exception。

Throwable体系：

Error:严重错误Error，无法通过处理的错误，只能事先避免，好比绝症。
Exception:表示异常，异常产生后程序员可以通过代码的方式纠正，使程序继续运行，是必须要处理的。好比感冒、阑尾炎。

Throwable中的常用方法：

public void printStackTrace():打印异常的详细信息。

包含了异常的类型,异常的原因,还包括异常出现的位置,在开发和调试阶段,都得使用printStackTrace。
public String getMessage():获取发生异常的原因。

提示给用户的时候,就提示错误原因。
public String toString():获取异常的类型和异常描述信息(不用)。

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

1.3 异常分类

我们平常说的异常就是指Exception，因为这类异常一旦出现，我们就要对代码进行更正，修复程序。

异常(Exception)的分类:根据在编译时期还是运行时期去检查异常?

编译时期异常:checked异常。在编译时期,就会检查,如果没有处理异常,则编译失败。(如日期格式化异常)
运行时期异常:runtime异常。在运行时期,检查异常.在编译时期,运行异常不会编译器检测(不报错)。(如数学异常)

小结

java.lang.Throwable:类是 Java语言中所有错误或异常的超类

Exception：编译期异常，进行编译（写代码）java程序出现的问题
- RuntimeException：运行期异常，java程序运行过程中出现的问题
  - 异常就相当于程序得了一个小毛病（感冒发烧），把异常处理掉，程序就可以继续执行（吃点药，继续革命工作）
- Error：错误
  - 错误就相当于程序得了一个无法治愈的得毛病（非典、新冠病毒），必须修改源代码，程序才能继续执行

public class Demo01Exception {
    public static void main(String[] args) {
        // Exception：编译期异常，进行编译（**写代码**）java程序出现的问题
        // 用来格式化日期
        SimpleDateFormat sdf = new SimpleDateFormat("yyy-MM-dd");
        Date date = null;
        try {
            // 吧字符串格式的日期，解析为Date格式的日期
            date = sdf.parse("1998-19-15");
        } catch (ParseException e) {
            e.printStackTrace();
        }
        System.out.println(date);

        // RuntimeException：**运行期异常**，java程序运行过程中出现的问题
        int[] arr = {1,2,3,5};
        /*System.out.println(arr[6]);
        // Demo01Exception*/
        try {
            // 可能会出现异常的代码
            System.out.println(arr[6]);
        }catch (Exception e){
            // 异常的处理逻辑
            System.out.println(e);
        }
        System.out.println("后续代码");
    }
}
//  运行结果
Thu Jul 15 00:00:00 CST 1999
java.lang.ArrayIndexOutOfBoundsException: 6
后续代码

1.4 异常的产生过程解析

先运行下面的程序，程序会产生一个数组索引越界异常ArrayIndexOfBoundsException。我们通过图解来解析下异常产生的过程。

第二章异常的处理

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

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

中断运行后边的代码不能执行

2.1 抛出异常throw

在编写程序时，我们必须要考虑程序出现问题的情况。比如，在定义方法时，方法需要接受参数。那么，当调用方法使用接受到的参数时，首先需要先对参数数据进行合法的判断，数据若不合法，就应该告诉调用者，传递合法的数据进来。这时需要使用抛出异常的方式来告诉调用者。

在java中，提供了一个throw关键字，它用来抛出一个指定的异常对象。那么，抛出一个异常具体如何操作呢？

创建一个异常对象。封装一些提示信息(信息可以自己编写)。
需要将这个异常对象告知给调用者。怎么告知呢？怎么将这个异常对象传递到调用者处呢？通过关键字throw就可以完成。throw 异常对象。

throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。

throw关键字小结

作用

可以使用throw关键字在指定的方法中抛出异常

作用格式

throw new xxxException（"异常产生的原因"）

注意：

throw关键字必须写在方法的内部
throw关键字后边new的对象必须是Exception或者Exception的子类对象
throw关键字抛除指定的异常对象，我们就必须对这个异常的对象进行处理
1. throw关键字后边创建的是RuntimeException 或者是RuntimeException的子类对象，我们可以不处理默认交给jvm处理（打印异常对象，中断程序）
2. throw关键字后创建的是编译异常（写代码时候报错），我们就必须处理这个异常，要么throws，要么try...catch

public class Demo03Throw {
    public static void main(String[] args) {
        int[] arr = new int[3];
        int i = getElement(arr, 3);
        System.out.println(i);
        /*
            定义一个方法，获取数组指定索引处的元素
            参数：
                int[] arr
                int index
            以后（工作中）我们首先必须对方法传递过来的参数进行合法性的校验
            如果参数不合法，那么我们就必须使用抛出异常的方式，告知方法的调用者，传递的参数有问题
            注意：
                NullPotionException是一个运行期异常，我们不用处理交给jvm处理
                ArrayIndexOutOfBoundsException也是一个运行期异常，我们不用处理交给jvm处理
         */
    }
    public static int getElement(int[] arr,int index) {
/*
    我们可以对传递过来的参数数组，进行合法性的校验
    如果数组arr的值为null
    那么我们就抛出空指针异常，告知方法的调用者“传递的数组的值为null”
*/
        if (arr == null) {
            throw new NullPointerException("传递的数组值是null");
        } else if (index >0 || index>arr.length-1) {
            throw new ArrayIndexOutOfBoundsException("传递的索引超出了范围");
        }
        int ele = arr[index];
        return ele;
    }
}

2.2 Objects非空判断

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

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

public class Demo04Objecrs {
    public static void main(String[] args) {
        method(null);
    }
    public static void method(Object obj){
        // 对传递过来的参数进行合法性判断，判断是否为null
        if (obj == null){
            throw new NullPointerException("传递过来的对象的值是null");
        }
        // 或者直接调用方法
        Objects.requireNonNull(obj,"传递的对象为空")
    }
}

2.3 声明异常throws

声明异常：将问题标识出来，报告给调用者。如果方法内通过throw抛出了编译时异常，而没有捕获处理（稍后讲解该方式），那么必须通过throws进行声明，让调用者去处理。

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

声明异常格式：

修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2…{   }

小结

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

作用：

当方法内部抛出异常对象的时候，那么我们就必须处理这个异常对象

可以使用throws关键字处理异常对象，会把异常对象声明抛出给方法的调用者处理（自己不处理，别人处理），最终交给jvm处理-->中断处理

使用格式

在方法声明时使用

修饰符返回值类型方法名（参数列表）throw 异常类名1,异常类名2…{

throw new 异类名1（”产生原因“）;

throw new 异类名2（”产生原因“）;

...

}

注意

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

声明异常的代码演示：

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

2.4 捕获异常try…catch

如果异常出现的话,会立刻终止程序,所以我们得处理异常:

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

try-catch的方式就是捕获异常。

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

捕获异常语法如下：

try{
     编写可能会出现异常的代码
}catch(异常类型  e){
     处理异常的代码
     //记录日志/打印异常信息/继续抛出异常
}

try：该代码块中编写可能产生异常的代码。

catch：用来进行某种异常的捕获，实现对捕获到的异常进行处理。

注意:try和catch都不能单独使用,必须连用。

小结

try...catch:异常处理的第二种方式（自己处理）

后边有代码继续执行

try...catch:异常处理的第二种方式，自己处理异常

格式

try{

可能产生异常的代码

}catch（定义一个异常的变量，用来接收try中跑出的异常对象）{

异常的处理逻辑，异常异常对象之后，怎么处理异常对象

一般在工作中，会吧异常的信息记录到一个日志中

}

...

catch(异常类名变量名){

}

注意

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

如果try中没有异常，那么就会不执行catch中的异常处理逻辑，执行完毕try中的代码，继续执行try...catch之后的代码

获取异常信息

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

public String getMessage():获取异常的描述信息,原因(提示给用户的时候,就提示错误原因。
public String toString():获取异常的类型和异常描述信息(不用)。
public void printStackTrace():打印异常的跟踪栈信息并输出到控制台。

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

演示如下：

public static void main(String[] args) throws IOException {
        try {
            // 可能产生的异常
            readFile("c:\a.td");
            // try 中抛出什么异常对象catch中就定义什么异常变量用来接收这异常对象
        }catch (IOException e){
            // 异常的处理逻辑，异常 异常对象之后，怎么处理异常对象
            System.out.println("catch - 传递的文件后缀不是.txt");
         /*
            Throwable类中定义了一些查看方法:

- `public String getMessage()`:获取异常的描述信息,原因(提示给用户的时候,就提示错误原因。

- `public String toString()`:获取异常的类型和异常描述信息(不用)。
- `public void printStackTrace()`:打印异常的跟踪栈信息并输出到控制台。

            *包含了异常的类型,异常的原因,还包括异常出现的位置,在开发和调试阶段,都得使用printStackTrace。*
             */
            // System.out.println(e.getMessage());// 文件的后缀名不对
            // System.out.println(e.toString());
            // 重写了Object类中的toString java.io.IOException:文件的后缀名不对
            // System.out.println(e.toString()); // java.io.IOException: 文件的后缀名不对

            /*
            java.io.IOException: 文件的后缀名不对
            at demo02Exception.Demo01TryCath.readFile(Demo01TryCath.java:71)
            at demo02Exception.Demo01TryCath.main(Demo01TryCath.java:45)
             */
            e.printStackTrace();
        }

        System.out.println("后续代码");
    }
    public static void readFile(String fileName) throws IOException {
        if (!fileName.endsWith(".txt")){
            throw new IOException("文件的后缀名不对");
        }
        System.out.println("路径没有问题，读取文件");
    }

2.4 finally 代码块

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

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

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

finally的语法:

try...catch....finally:自身需要处理异常,最终还得关闭资源。

注意:

finally不能单独使用，必须和try一起使用

finally一般用于资源释放（资源回收），无论程序是否出现异常，最后都要释放（IO）

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

finally代码参考如下：

public static void main(String[] args) {
        try {
            // 可能产生的异常
            readFile("c:\a.td");
            // try 中抛出什么异常对象catch中就定义什么异常变量用来接收这异常对象
        }catch (IOException e){
            // 异常处理的逻辑
            e.printStackTrace();
        }finally {
            System.out.println("资源释放");
        }
    }
    public static void readFile(String fileName) throws IOException {
        if (!fileName.endsWith(".txt")){
            throw new IOException("文件的后缀名不对");
        }
        System.out.println("路径没有问题，读取文件");
    }

2.5 异常注意事项

多个异常使用捕获又该如何处理呢？
1. 多个异常分别处理。
2. 多个异常一次捕获，多次处理。
  
  注意事项：
  
  也就是一个try多个catch，catch中定义的异常变量，如果有子父类关系，那么子类的异常变量必须写在上边，否则就会报错
3. 多个异常一次捕获一次处理。
一般我们是使用一次捕获多次处理方式，格式如下：
```
try{
     编写可能会出现异常的代码
}catch(异常类型A  e){  当try中出现A类型异常,就用该catch来捕获.
     处理异常的代码
     //记录日志/打印异常信息/继续抛出异常
}catch(异常类型B  e){  当try中出现B类型异常,就用该catch来捕获.
     处理异常的代码
     //记录日志/打印异常信息/继续抛出异常
}
```

1585408576845

注意:这种异常处理方式，要求多个catch中的异常不能相同，并且若catch中的多个异常之间有子父类异常的关系，那么子类异常要求在上面的catch处理，父类异常在下面的catch处理。

运行时异常被抛出可以不处理。即不捕获也不声明抛出。

如果finally有return语句,永远返回finally中的结果,避免该情况.

示例代码

public static void main(String[] args){
    int a = getA();
    System.out.println(a);
}
public static int getA(){
    int a = 10;
    try{
        return a;
    }catch(Exception e){
        System.out.println(e);
    }finally{
        int a = 100;
        return a;
    }
}
// 运行结果  a= 100；

父类异常，子类的必须是相同异常

如果父类抛出了多个异常,子类重写父类方法时,抛出和父类相同的异常或者是父类异常的子类或者不抛出异常。
父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出

示例代码：

public class Fu {
    public void show01() throws NullPointerException,ClassCastException{}
    public void show02() throws IndexOutOfBoundsException{}
    public void show03() throws IndexOutOfBoundsException{}
    public void show04() {}


}
class Zi extends Fu{
    /**
     * 子类重写父类方法时,抛出和父类相同的异常
      * @throws NullPointerException 空指针异常
     * @throws ClassCastException 类强制转换异常
     */
    @Override
    public void show01() throws NullPointerException,ClassCastException{}

    /**
     * 子类重写父类方法时,抛出父类异常的子类
      * @throws ArrayIndexOutOfBoundsException  数组索引越界异常
     */
    @Override
    public void show02() throws ArrayIndexOutOfBoundsException{}

    /**
     * 子类重写父类方法时，不抛出异常
      */
    @Override
    public void show03(){}

    /**
     * 此时子类产生该异常，只能捕获处理try..catch，不能声明抛出
     */
    @Override
    public void show04(){
        try {
            throw new Exception("编译器异常");
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

第三章自定义异常类

3.1 概述

为什么需要自定义异常类:

我们说了Java中不同的异常类,分别表示着某一种具体的异常情况,那么在开发中总是有些异常情况是SUN没有定义好的,此时我们根据自己业务的异常情况来定义异常类。例如年龄负数问题,考试成绩负数问题等等。

在上述代码中，发现这些异常都是JDK内部定义好的，但是实际开发中也会出现很多异常,这些异常很可能在JDK中没有定义过,例如年龄负数问题,考试成绩负数问题.那么能不能自己定义异常呢？

什么是自定义异常类:

在开发中根据自己业务的异常情况来定义异常类.

自定义一个业务逻辑异常: RegisterException。一个注册异常类。

异常类如何定义:

自定义一个编译期异常: 自定义类并继承于java.lang.Exception。
自定义一个运行时期的异常类:自定义类并继承于java.lang.RuntimeException。

小结

java提供的异常类：不够我们使用，需要自己定义一些异常类

格式

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

注意

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

public class RegisterException extends Exception {
    // 添加一个空参数构造方法
    public RegisterException(){
        super();
    }
    /**
    添加一个带异常信息的构造方法
    查看源码发现，所有的异常类都会有一个带异常信息的构造方法，方法的内部会调用父类带异常信息的构造方法，让父类来处理这个异常信息
     */
    public RegisterException(String message){
        super(message);
    }
}

3.2 自定义异常的练习

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

分析：

使用数组保存已经注册过的用户名（数据库）
使用Scanner获取用户输入的注册的用户名（前端，页面）
定义一个方法，对用户输入注册的用户名进行判断
1. 遍历存储已经注册的用户名数组，获取每一个用户名
2. 使用获取到的用户名和用户输入注册的用户名进行比较
  1. true：用户名已经存在，抛出RegisterException异常，告知用户“该用户名已经被注册”
  2. false：继续遍历比较
3. 如果循环结束，还没有找到重复的用户名，提示用户“恭喜您，注册成功！”

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

    public static void main(String[] args) {
        // 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:username){
            //使用获取到的用户名和用户输入的用户名比较
            if (name.equals(username)){
                // 1. true：用户名已经存在，抛出RegisterException异常，告知用户“该用户名已经被注册”
                throw new RegisterException("该用户名已经存在");
            }
        }
        // 3. 如果循环结束，还没有找到重复的用户名，提示用户“恭喜您，注册成功！”

        System.out.println("恭喜您，注册成功");
    }
}

第四章多线程

我们在之前，学习的程序在没有跳转语句的前提下，都是由上至下依次执行，那现在想要设计一个程序，边打游戏边听歌，怎么设计？

要解决上述问题,咱们得使用多进程或者多线程来解决.

4.1 并发与并行

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

例子：一个人吃两个馒头
并行：指两个或多个事件在同一时刻发生（同时发生）。

例子：两个人吃两个馒头

在操作系统中，安装了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，这在单 CPU 系统中，每一时刻只能有一道程序执行，即微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分时交替运行的时间是非常短的。

而在多个 CPU 系统中，则这些可以并发执行的程序便可以分配到多个处理器上（CPU），实现多任务并行执行，即利用每个处理器来处理一个可以并发执行的程序，这样多个程序便可以同时执行。目前电脑市场上说的多核 CPU，便是多核处理器，核越多，并行处理的程序越多，能大大的提高电脑运行的效率。

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

4.2 线程与进程

进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。

就是进入到内存中的程序
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程

我们可以再电脑底部任务栏，右键----->打开任务管理器,可以查看当前任务的进程：

进程

线程

线程调度:

分时调度

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

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

大部分操作系统都支持多进程并发运行，现在的操作系统几乎都支持同时运行多个程序。比如：现在我们上课一边使用编辑器，一边使用录屏软件，同时还开着画图板，dos窗口等软件。此时，这些程序是在同时运行，”感觉这些软件好像在同一时刻运行着“。

实际上，CPU(中央处理器)使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是在同一时刻运行。
其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。

主线程

举例

JVM执行main方法，main方法就会进入到栈内存
JVM栈会操作系统开辟出一条main方法通向CPU的执行路径
cup就可以通过这个路径来执行main方法
这个路径就叫做main（主）线程

示例代码

Person类

public class Person {
    private String name;

    public Person(){

    }
    public Person(String name){
        this.name = name;
    }
    public void run(){
        for (int i = 0; i < 20; i++) {
            System.out.println(name+" "+i);
        }
    }
    public String getName(){
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

测试类

public class Demo01MainThread {
    public static void main(String[] args) {
        Person p1 = new Person("张三");
        p1.run();
        Person p2 = new Person("赵四");
        p2.run();
    }
}

4.3 创建线程类

Java使用java.lang.Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。Java中通过继承Thread类来创建并启动多线程的步骤如下：

定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。
创建Thread子类的实例，即创建了线程对象
调用线程对象的start()方法来启动该线程

小结

创建多线程的第一种方式

创建Thread类的子类

java.lang.Thread类：是描述线程的类，我们想要实现多线程，就必须继承Thread类

步骤

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

java程序属于抢占式调度，哪个线程优先级高，哪个线程优先执行；同一个优先级，随机选一个

代码如下：

MyThread类

// 创建一个Thread类的子类
public class MyThread extends Thread{
    @Override
    public void run(){
        for(int i = 0;i <6;i++){
            System.out.println("run"+i);
    }
}

测试类

public static void main(String[] args){
    MyThread md = new MyThread();
    md.run();
    for(int i = 0;i <6;i++){
            System.out.println("main"+i);
    }
}
// 运行结果
run0
run1
run2
run3
run4
run5
main0
main1
main2
main3
main4
main5

多线程随机打印结果