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关键字，它用来抛出一个指定的异常对象。那么，抛出一个异常具体如何操作呢？

1. 创建一个异常对象。封装一些提示信息(信息可以自己编写)。

2. 需要将这个异常对象告知给调用者。怎么告知呢？怎么将这个异常对象传递到调用者处呢？通过关键字throw就可以完成。throw 异常对象。

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

throw关键字小结

作用

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

作用格式

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

注意：

1. throw关键字必须写在方法的内部
2. throw关键字后边new的对象必须是Exception或者Exception的子类对象
3. 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（”产生原因“）;

​ ...

}

注意

1. throws关键字必须写在方法声明处
2. throws关键字后边声明的异常必须是Exception或者是Exception的子类
3. 方法内部如果抛出了多个异常对象，那么throws后也必须声明多个异常
   1. 如果抛出了多个异常对象有子父类关系，那么直接声明父类异常即可
4. 调用了一个声明抛出异常的方法，我们就必须得处理声明的异常
   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

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

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

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

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

捕获异常语法如下：

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

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

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

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

小结

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

后边有代码继续执行

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

格式

​ try{

​ 可能产生异常的代码

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

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

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

​ }

​ ...

​ catch(异常类名 变量名){

​ }

注意

1. try中可能会抛出多个异常对象，那么就可以使用多个catch来处理这些异常对象

2. 如果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:自身需要处理异常,最终还得关闭资源。

注意:

1. finally不能单独使用，必须和try一起使用
2. 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来捕获.
       处理异常的代码
       //记录日志/打印异常信息/继续抛出异常
  }
  

注意:这种异常处理方式，要求多个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。一个注册异常类。

异常类如何定义:

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

小结

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

格式

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

注意

1. 自定义的类一般是Exception结尾，说名该类是一个异常类
2. 自定义异常类，必须是继承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 自定义异常的练习

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

分析：

1. 使用数组保存已经注册过的用户名（数据库）
2. 使用Scanner获取用户输入的注册的用户名（前端，页面）
3. 定义一个方法，对用户输入注册的用户名进行判断
   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的使用率更高。

主线程

举例

1. JVM执行main方法，main方法就会进入到栈内存
2. JVM栈会操作系统开辟出一条main方法通向CPU的执行路径
3. cup就可以通过这个路径来执行main方法
4. 这个路径就叫做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类来创建并启动多线程的步骤如下：

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

小结

创建多线程的第一种方式

创建Thread类的子类

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

步骤

1. 创建一个Thread类的子类
2. 在Thread类的子类中重写Thread类中的run方法，设置线程任务（开启线程要做什么？）
3. 创建Thread类的子类对象
4. 调用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

多线程随机打印结果