02_Java语音进阶||day05_异常，异常的处理，自定义异常，线程

其他 2020-04-24 21:01:21 阅读次数: 0

第一章 异常

1.1 异常概念

  1. 异常： 就是不正常的意思（字面）
  2. 异常：指的是程序在执行过程中，出现的非正常情况，最终会导致JVM的非正常停止。
  3. 在Java中，异常本身就是一个类，产生异常就是创建异常对象并抛出了一个异常对象。Java的处理方式是中断处理
  • 注：异常指的并不是语法错误，如果语法错了，编译不会通过，不会产生字节码文件，根本不能运行。

1.2 异常体系

  1. 异常的根类：java.lang.Throwable，其中两个子类：java.lang.Error和java.lang.Exception【异常平时指它】


2. Throwable体系：
* Error：严重错误Error，无法通过处理的错误，只能事先避让，比如：绝症
* Exception：表示异常，异常产生后程序员可以通过代码的方式纠正，使程序继续运行，是必须要处理的，比如：感冒，阑尾炎
* 注：留意一下RuntimeExcepition（Exception子类）：运行期间抛出的异常

1.3 异常分类

  1. java.lang.Throwable:类是 Java 语言中所有错误或异常的超类。
    1. Exception:编译期异常【!】,进行编译(写代码)java程序出现的问题——我们就必须处理这个异常，要么throws或者try…catch【重点】
      • RuntimeException:运行期异常【!】,java程序运行过程中出现的问题——我们不用处理，交给JVM处理【重点】
      • 异常就相当于程序得了一个小毛病(感冒,发烧),把异常处理掉,程序可以继续执行(吃点药,继续革命工作)
    2. Error:错误
      • 错误就相当于程序得了一个无法治愈的毛病(非典,艾滋).必须修改源代码,程序才能继续执行
  2. 处理异常方式：
    1. 虚拟机处理异常
    2. try/catch处理异常
      • 该处理方式处理，程序可以正常运行
          try{
        //存放可以存着异常的代码
    }catch (Exception e){
        //异常的处理逻辑(出现异常该怎么处理)
        System.out.println(e);
    }

    public static void main(String[] args) throws ParseException {
        //Exception：编译异常
        /*SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");  //格式化日期
        Date date = sdf.parse("1999-09-09"); //将字符串日期，解析成Date日期
        System.out.println(date);
        Date date1 = new Date();
        String format1 = sdf.format(date1);
        System.out.println(format1);*/

        //RuntimeException:运行期异常
/*        int[] a = {1, 2, 3};
        try{
            //存放可以存着异常的代码
            System.out.println(a[3]);
        }catch (Exception e){
            //异常的处理逻辑(出现异常该怎么处理)
            System.out.println(e);  //ArrayIndexOutOfBoundsException: 3
        }*/

        //Error
        //int[] i = new int[1024*1024*1024];  //OutOfMemoryError: Java heap space(内存溢出)
        //Error必须修改代码
        int[] i = new int[1024];

    }

1.4 异常的产生过程解析

  • 注：JVM会根据异常产出异常对象，异常对象包含了异常产生的（内容，原因，位置）

第二章 异常的处理

2.1 抛出异常throw

  • Java异常处理的五个关键字【重点】：try,catch,finally,throw,throws
  1. throw关键字：
    1. 作用：可以使用throw关键字在指定的方法中抛出指定的异常
    2. 使用格式：
          throw new xxxException("异常产生的原因");

    //例：
    if () { //方法传递过来的参数进行合法性校验
        throw new xxxException("异常产生的原因");
    }
    3. 注意事项：
      1. throw关键字必须写在方法的内部
      2. throw关键字后面new的对象必须是Exception或者Exception的子类对象
      3. throw关键字抛出指定的异常对象，我们就必须处理这个异常对象
        • throw关键字后边创建的是RuntimeException或者是RuntimeException的子类对象，我们可以不出来，交给JVM处理（打印异常对象，中断异常）
        • throw关键字后面创建的是编译异常（写代码的时候报错），我们就必须处理这个异常，要么throws或者try…catch
  • 注：以后(工作中)我们首先必须对方法传递过来的参数进行合法性校验【重点】
    • 如果参数不合法,那么我们就必须使用抛出异常的方式,告知方法的调用者,传递的参数有问题
  • 注：NullPointerException（空指针异常）是一个运行期异常，我们不用处理，交给JVM处理
  • 注：ArrayIndexOutOfBoundsException(数组索引越界异常)是一个运行期异常，我们不用处理，交给JVM处理
    public class Demo03Throw {
        public static void main(String[] args) {
            //int[] arr = null;
            int[] arr = new int[3];
            getElement(arr, 3);
        }
    
        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("传递的索引超出了数组的使用范围");
            }
            return arr[index];
        }
    }

2.2 Objects非空判断

  1. Objects类中的静态方法（JDK1.7工具类）
  2. public static T requireNonNull(T obj):查看指定引用对象不是null。
    • 也可以(obj, “异常信息”);
  3. 源码:
        public static <T> T requireNonNull(T obj) {
        if (obj == null)
            throw new NullPointerException();
        return obj;
    }
  4. 发现和2.1中是否为null的合理性校验类似
        if(arr == null){
            throw new NullPointerException("传递数组的值是null");
    }
  5. 所以我们可以把2.1替换为：
        public class Demo04Objects {
        public static void main(String[] args) {
            method(null);
        }
    
        public static void method(Object obj){
    /*        if(obj == null){
                throw new NullPointerException("传递数组的值是null");
            }*/
            //替换为：
            //Objects.requireNonNull(obj);
            Objects.requireNonNull(obj, "传递数组的值是null");
        }
    }
  6. 作用：
    • Objects.requireNonNull方法的作用就是简化，方法合法性校验中空指针异常代码的书写

2.3 声明异常throws—异常处理的第一种方式（交给别人）

  1. throws关键字:异常处理的第一种方式,交给别人处理
  2. 作用:
    1. 当方法内部抛出异常对象的时候,那么我们就必须处理这个异常对象
    2. 可以使用throws关键字处理异常对象,会把异常对象声明抛出给方法的调用者处理(自己不处理,给别人处理),最终交给JVM处理–>中断处理
  3. 使用格式:在方法声明时使用【!】
        修饰符 返回值类型 方法名(参数列表) throws AAAExcepiton,BBBExcepiton...{
        throw new AAAExcepiton("产生原因");
        throw new BBBExcepiton("产生原因");
        ...
    }
  • 注意事项:
    1. throws关键字必须写在方法声明处
    2. throws关键字后边声明的异常必须是Exception或者是Exception的子类
    3. 方法内部如果抛出了多个异常对象,那么throws后边必须也声明多个异常
      • 如果抛出的多个异常对象,有子父类关系,那么直接声明父类异常即可【!】
    4. 调用了一个声明抛出异常的方法,我们就必须的处理声明的异常【重点】
      • 要么继续使用throws声明抛出,交给方法的调用者处理【!】,最终交给JVM
      • 要么try…catch自己处理【!】异常
    public class Demo05Throws {
        /*
            FileNotFoundException extends IOException extends Excepiton
            如果抛出的多个异常对象有子父类关系,那么直接声明父类异常即可
         */
        //public static void main(String[] args) throws FileNotFoundException, IOException {
        //public static void main(String[] args) throws IOException {
        public static void main(String[] args) throws Exception {
            readFile("c:\\a.txt");
            
            System.out.println("后续代码"); //如果抛出异常时候，不执行!!
        }
    
        /*
        定义一个方法，对传递的文件路径进行合法性判断
        如果路径不是"c:\\a.txt",那么我们就抛出文件找不到异常对象,告知方法的调用者
         */
        public static void readFile(String fileName) throws IOException {
            /*
                如果传递的路径,不是.txt结尾
                    那么我们就抛出IO异常对象,告知方法的调用者,文件的后缀名不对
             */
            if(!fileName.endsWith(".txt")){
                throw new IOException("文件的后缀名不对");
            }
    
            if(!fileName.equals("c:\\a.txt")){
                throw new FileNotFoundException("传递的文件路径不是c:\\a.txt");
            }
    
            System.out.println("路径没有问题");
        }
    }
  • 注：
    • 使用声明异常throws之后，如果抛出异常时候，后面还有代码就不在执行【!】–>程序就停了
  • 注：
    • FileNotFoundException是编译异常,抛出了编译异常,就必须处理这个异常
      • 可以使用throws继续声明抛出FileNotFoundException这个异常对象,让方法的调用者处理
  • 注：
    • FileNotFoundException extends IOException extends Excepiton【!】
      • 如果抛出的多个异常对象有子父类关系,那么直接声明父类异常即可

2.4 捕获异常try…catch—异常处理的第二种方式（自己处理异常）

  1. 声明异常throws的缺点：
    1. 使用声明异常throws之后，如果抛出异常时候，后面还有代码就不在执行【!】–>程序就停了
      • 因为最终交给JVM处理–>中断处理
  2. try…catch:异常处理的第二种方式,自己处理异常
    • 在抛出异常的时候还能执行后面的程序【!】
  3. 格式:
        try{
        可能产生异常的代码
    }catch(定义一个异常的变量,用来接收try中抛出的异常对象){
        异常的处理逻辑,产生异常对象之后,怎么处理异常对象
        一般在工作中,会把异常的信息记录到一个日志中
    }
    ...
    catch(异常类名 变量名){

    }
    
    //例子：
    try{
        readFile("d:\\a.txt");
    }catch (IOException e){
        System.out.println("catch - 传递的文件后缀不是.txt");
    }
    • 注：try中抛出什么异常对象,catch就定义什么异常变量,用来接收这个异常对象
  4. 注意事项:
    1. try中可能会抛出多个异常对象,那么就可以使用多个catch来处理这些异常对象
    2. 如果try中++产生++了异常【!】,那么就会执行catch中的异常处理逻辑,执行完毕catch中的处理逻辑,继续执行try…catch之后的代码
    3. 如果try中没有产生异常【!】,那么就不会执行catch中异常的处理逻辑,执行完try中的代码,继续执行try…catch之后的代码
    public class Demo01TryCatch {
        public static void main(String[] args){
            try{
                //可能产生异常的代码
                readFile("d:\\a.txt");
            }catch (IOException e){ //try中抛出什么异常对象,catch就定义什么异常变量,用来接收这个异常对象
                //异常的处理逻辑,产生异常对象之后,怎么处理异常对象
                System.out.println("catch - 传递的文件后缀不是.txt");
            }
    
            System.out.println("后续代码"); //如果抛出异常时候也能执行
        }
    
    
        /*
        如果传递的路径,不是.txt结尾
            那么我们就抛出IO异常对象,告知方法的调用者,文件的后缀名不对
        */
        public static void readFile(String fileName) throws IOException {
    
            if(!fileName.endsWith(".txt")){
                throw new IOException("文件的后缀名不对");
            }
    
            System.out.println("路径没有问题");
        }
    }
    
    //结果：
    java.io.IOException: 文件的后缀名不对
    	at cn.javaadvance.day05.demo02.Demo01TryCatch.readFile(Demo01TryCatch.java:41)
    	at cn.javaadvance.day05.demo02.Demo01TryCatch.main(Demo01TryCatch.java:9)
    后续代码

2.5 Throwable类中3个异常处理的方法

  1. String getMessage()
    • 返回此 throwable 的简短描述。
        try{
        readFile("d:\\a.tx");
    }catch (IOException e){
        System.out.println(e.getMessage()); //文件的后缀名不对
    }
  2. String toString()——重写了Object类的toString方法
    • try…catch默认此方法【!】,返回此 throwable 的详细消息字符串。
        try{
        readFile("d:\\a.tx");
    }catch (IOException e){
        System.out.println(e.toString());   //java.io.IOException: 文件的后缀名不对
        //默认同toString
        System.out.println(e);  //java.io.IOException: 文件的后缀名不对
    }
  3. void printStackTrace()——（无返回值）
    • JVM打印异常对象,默认此方法【!】,打印的异常信息是最全面的
        try{
        readFile("d:\\a.tx");
    }catch (IOException e){
        e.printStackTrace();
    }
    
    //结果:
    java.io.IOException: 文件的后缀名不对
        at cn.javaadvance.day05.demo02.Demo01TryCatch.readFile(Demo01TryCatch.java:36)
        at cn.javaadvance.day05.demo02.Demo01TryCatch.main(Demo01TryCatch.java:9)

2.6 finally代码块

  1. finally:有一些特点的代码无论异常是否发生，都需要执行。
    • 比如try中异常对象如果发生异常就不会执行try中下面的代码
  2. finally代码块
  3. 格式:
        try{
        可能产生异常的代码
    }catch(定义一个异常的变量,用来接收try中抛出的异常对象){
        异常的处理逻辑,异常异常对象之后,怎么处理异常对象
        一般在工作中,会把异常的信息记录到一个日志中
    }
    ...
    catch(异常类名 变量名){

    }finally{
        无论是否出现异常都会执行
    }
  4. 注意实现:
    1. finally不能单独使用,必须和try一起使用
    2. finally一般用于资源释放【!】(资源回收),无论程序是否出现异常,最后都要资源释放(IO)
    public class Demo02TryCatchFinally {
        public static void main(String[] args) {
            try {
                //可能会产生异常的代码
                readFile("d:\\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("后缀名没有问题");
        }
    }
    
    //无异常结果：
    后缀名没有问题
    资源释放
    //抛出异常结果：
    java.io.IOException: 文件的后缀名不对
    	at cn.javaadvance.day05.demo02.Demo02TryCatchFinally.readFile(Demo02TryCatchFinally.java:27)
    	at cn.javaadvance.day05.demo02.Demo02TryCatchFinally.main(Demo02TryCatchFinally.java:9)
    资源释放
  • 注：try…catch可以用alt+enter快捷

2.7 异常的注意事项—多异常的捕获处理

  • 多个异常使用捕获又该如何处理呢？
  1. 多个异常分别处理。
        try {
        int[] arr = {1,2,3};
        System.out.println(arr[3]);//ArrayIndexOutOfBoundsException: 3
    }catch (ArrayIndexOutOfBoundsException e){
        System.out.println(e);
    }

    try{
        List<Integer> list = List.of(1, 2, 3);
        System.out.println(list.get(3));//IndexOutOfBoundsException: Index 3 out-of-bounds for length 3
    }catch (IndexOutOfBoundsException e){
        System.out.println(e);
    }
  2. 多个异常一次捕获，多次处理。
    • 一个try多个catch注意事项:(从上到下依次)
      • catch里边定义的异常变量,如果有子父类关系,那么子类的异常变量必须写在上边,否则就会报错【重点】
      • ArrayIndexOutOfBoundsException（数组越界异常） extends IndexOutOfBoundsException（集合越界异常）
        try {
        int[] arr = {1,2,3};
        //System.out.println(arr[3]);//ArrayIndexOutOfBoundsException: 3
        List<Integer> list = List.of(1, 2, 3);
        System.out.println(list.get(3));//IndexOutOfBoundsException: Index 3 out-of-bounds for length 3
    }catch (ArrayIndexOutOfBoundsException e){
        System.out.println(e);
    }catch (IndexOutOfBoundsException e){
        System.out.println(e);
    }


3. 多个异常一次捕获一次处理。

        try {
            int[] arr = {1,2,3};
            //System.out.println(arr[3]);//ArrayIndexOutOfBoundsException: 3
            List<Integer> list = List.of(1, 2, 3);
            System.out.println(list.get(3));//IndexOutOfBoundsException: Index 3 out-of-bounds for length 3
        }catch (Exception e){
            System.out.println(e);
        }
  • 注：catch异常类型把try中异常都包含即可
  • 注意事项：
    1. 运行时异常被抛出可以不处理
      • 即不捕获也不声明抛出
      • 默认给虚拟机处理,终止程序,什么时候不抛出运行时异常了,在来继续执行程序

2.8 异常的注意事项—finally有return语句

  1. 如果finally有return语句，永远返回finally中的结果，避免该情况发生
    public class Demo02Exception {
        public static void main(String[] args) {
            int a = getA();
            //永远返回的是finally中的值
            System.out.println(a);  //100
        }
    
        //定义一个方法，返回变量a的值
        public static int getA(){
            int a = 10;
            try{
                return a;
            }catch (Exception e){
                System.out.println(e);
            }finally {
                a = 100;
                return a;
            }
        }
    }

2.9 异常的注意事项—子父类异常

  1. 子父类的异常:
    • 如果父类抛出了多个异常,子类重写父类方法时,抛出和父类相同的异常或者是父类异常的子类或者不抛出异常。
    • 父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出
  2. 注意事项:
    • 父类异常时什么样,子类异常就什么样【总结】
  • 注：ClassCastException——类型转换异常
    //定义了一个Fu和Zi在同一个类：Fu.class
    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{
        //子类重写父类方法时,抛出和父类相同的异常
        public void show01() throws NullPointerException, ClassCastException{}
        //子类重写父类方法时,抛出父类异常的子类
        public void show02() throws ArrayIndexOutOfBoundsException{}
        //子类重写父类方法时,不抛出异常
        public void show03() {}
    
        //子类重写父类该方法时也不可抛出异常
        //public void show04() {} //true
        //public void show04() throws Exception{}错，不能抛出异常
        //此时子类产生该异常，只能捕获处理，不能声明抛出
        public void show04() {
            try {
                throw new Exception("编译器异常");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        
        //错，不能抛出异常，因为父类没有异常
    /*    public void show04() throws Exception{
            throw new Exception("编译器异常");
        }*/
    }

第三章 自定义异常

3.1 概述

  1. 自定义异常类:
    • java提供的异常类,不够我们使用,需要自己定义一些异常类
  2. 格式:
        public class XXXExcepiton extends Exception | RuntimeException{
        添加一个空参数的构造方法
        添加一个带异常信息的构造方法
    }
    • 注：添加一个带异常信息的构造方法
      • 查看源码发现,所有的异常类都会有一个带异常信息的构造方法,
      • 方法内部会调用父类带异常信息的构造方法,让父类来处理这个异常信息
    • 注：同上，空参方法要调用父类的空参构造方法
        public class RegisterException extends Exception{
        //空参方法要调用==父类的空参构造方法
        public RegisterException(){
            super();
        }
    
        //添加一个带异常信息的构造方法
        //方法内部会==调用父类==带异常信息的构造方法,==让父类来处理这个异常信息==
        public RegisterException(String message){
            super(message);
        }
    }
  3. 注意事项：
    1. 自定义异常类一般都是以Exception结尾,说明该类是一个异常类
    2. 自定义异常类,必须的继承Exception或者RuntimeException
      • 继承Exception:那么自定义的异常类就是一个编译期异常,如果方法内部抛出了编译期异常,就必须处理这个异常,要么throws,要么try…catch
      • 继承RuntimeException:那么自定义的异常类就是一个运行期异常,无需处理,交给虚拟机处理(中断处理)

3.2 自定义异常练习

  1. 要求：我们模拟注册操作，如果用户名已存在，则抛出异常并提示：亲，该用户名已经被注册。
  2. 分析:
    1. 使用数组保存已经注册过的用户名(数据库)
    2. 使用Scanner获取用户输入的注册的用户名(前端,页面)
    3. 定义一个方法,对用户输入的中注册的用户名进行判断
      • 遍历存储已经注册过用户名的数组,获取每一个用户名
      • 使用获取到的用户名和用户输入的用户名比较
        • true:
          • 用户名已经存在,抛出RegisterException异常,告知用户"亲，该用户名已经被注册";
        • false:
          • 继续遍历比较
      • 如果循环结束了,还没有找到重复的用户名,提示用户"恭喜您,注册成功!";
    //当自定义异常类继承Exception的情况——编译期异常（需要处理异常）
    //自定义异常类：RegisterException.class
    public class RegisterException extends Exception{
        //空参方法要调用==父类的空参构造方法
        public RegisterException(){
            super();
        }
    
        //添加一个带异常信息的构造方法
        //方法内部会==调用父类==带异常信息的构造方法,==让父类来处理这个异常信息==
        public RegisterException(String message){
            super(message);
        }
    }
    
    //主方法：Demo01RegisterException.class
    public class Demo01RegisterException {
        //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("恭喜您,注册成功!");
        }
    }
  • 注：方法中抛出异常后不想在执行后面的方法，可以return;
    //当自定义异常类继承RuntimeException的情况——运行期异常（无需处理）
    //自定义异常类：RegisterException.class
    public class RegisterException extends RuntimeException{
        //空参方法要调用==父类的空参构造方法
        public RegisterException(){
            super();
        }
    
        //添加一个带异常信息的构造方法
        //方法内部会==调用父类==带异常信息的构造方法,==让父类来处理这个异常信息==
        public RegisterException(String message){
            super(message);
        }
    }
    
    //主方法：Demo02RegisterException.class
    public class Demo02RegisterException {
        //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异常,告知用户"亲，该用户名已经被注册";
                    throw new RegisterException("亲，该用户名已经被注册");
    /*                try {
                        throw new RegisterException("亲，该用户名已经被注册");
                    } catch (RegisterException e) {
                        e.printStackTrace();
                        return; //结束方法
                    }*/
                }
            }
    
            //如果循环结束了,还没有找到重复的用户名,提示用户"恭喜您,注册成功!";
            System.out.println("恭喜您,注册成功!");
        }
    }

第四章 多线程

4.1 并发与并行

  1. 并发：指两个或多个事件在同一个时间段内发生
    • 交替执行【!】
  2. 并行：值两个或多个事件在同一时刻发生
    • 同时执行【!】

4.2 线程与进程—进程概念

  1. 进程：进入到内存的程序（每个打开的软件就是一个进程）
    • 点击应用程序执行，进入到内存中，占用一些内存执行
  2. 关闭进程：
    • 任务管理器–>结束进程（那么就把进程从内存中清除了）
  • 注：
    • 永久存储ROM：硬盘
    • 临时存储RAM：内存（所有的应用程序都需要进入到内存中执行）

4.3 线程与进程—线程概念

  1. CPU：中央处理器
    • 对数据进行计算，指挥电脑中软件和硬件干活
  2. CPU的分类：
    • AMD
    • Inter
      • Inter Core(核心) i7 8866 4核心8线程
      • 8线程：同时执行8个任务
  3. 线程举例：各种杀毒软件（是一个进程）中同时进行不同功能
  4. 线程概念引入：
    • 点击杀毒软件功能（病毒查杀，清理垃圾，电脑加速）执行
    • 就会开启一条应用程序到cpu的执行路径
    • cpu就可以通过这个路径执行功能
    • 这个路径有一个名字，叫线程（通向cpu的执行路径）
  5. 线程属于进程【!】
    • 是进程中的一个执行单元，负责程序的执行。
  6. 单核心单线程cpu—执行多线程功能
    • cpu在多个线程之间做高速的切换
    • 轮流执行多个线程
    • 效率低
    • 切换的速度（1/n毫秒）
  7. 4核心8线程cpu—执行多线程功能
    • 有8个线程：可以同时执行8个线程
    • 8个线程在多个任务之间做高速的切换
    • 速度是单线程的8倍（每个任务被执行的几率都提高了8倍）
  8. 多线程的好处：
    1. 效率高
    2. 多个线程之间互不影响

4.4 线程调度（分时调度，抢占式调度）

  • 对于CPU的核而言，某个时刻，只能执行一个线程。而CPU多线程的切换速度相对较快，看上去就像同时在执行【!】
  • 其实：多线程程序并不能提高程序的运行速度，但能提高程序运行效率，让CPU的使用率更高【重点】
  1. 分时调度：
    • 所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间
    • 比如4.3中有杀毒软件有三个线程，系统分配杀毒软件执行时间9秒，则每个线程3秒钟。
  2. 抢占式调度：
    1. 优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个（线程随机性）
      • Java使用的为抢占式调度
    2. 设置线程的优先级：(win10在详细信息中)
  3. 抢占式调度详解：

4.5 主线程

  1. 主线程:执行主(main)方法的线程
    • 单线程程序:java程序中只有一个线程
    • 执行从main方法开始,从上到下依次执行
  2. 单线程的弊端：
    • 当程序中间抛出异常，则中断程序后，后面就不能执行了

  • JVM执行main方法,main方法会进入到栈内存
  • JVM会找操作系统开辟一条main方法通向cpu的执行路径
  • cpu就可以通过这个路径来执行main方法
  • 而这个路径有一个名字,叫main(主)线程

4.6 创建线程类的第一种方式—创建Thread类的子类

  • 我们之前写的所有代码都是单线程

  1. 创建多线程程序的第一种方式:创建Thread类的子类，重写Thread类中的run方法【重点】

    • java.lang.Thread类:是描述线程的类,我们想要实现多线程程序,就必须继承Thread类

  2. 实现步骤:

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

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

    //定义一个Thread类的子类（继承Thread）：MyThread.class
    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);
            }
        }
    }
    
    //主方法：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);
        }
    }
    
    //结果：(每次都不太一样)
    main:0
    main:1
    main:2
    run:0
    main:3
    run:1
    main:4
    run:2
    main:5
    run:3
    main:6
    run:4
    main:7
    run:5
    main:8
    run:6
    main:9
    run:7
    main:10
    run:8
    main:11
    run:9
    main:12
    run:10
    main:13
    run:11
    main:14
    run:12
    run:13
    run:14
    run:15
    run:16
    run:17
    run:18
    run:19
    main:15
    main:16
    main:17
    main:18
    main:19
  • 注：
    • 由于是多线程执行，所以每次执行的结果都太不一样。

今天自我心得：

  • 异常和多线程本身都是一个类
  • 异常作用：知道发生什么异常，可以让因为异常停止的程序继续，可以通过finally清空内存，但是别没讲说后面讲IO时候说
  • 多线程作用：提高CPU使用率，提高速度，但是不能提高运行速度
  • 异常体系：Throwable中有Error（必须修改源代码）和Exception（常说的异常）；
  • 异常分类：在编译期异常，有两种（声明异常throws（方法声明时），捕获异常try…catch），在运行期异常直接抛出异常（throw new 异常(“异常原因”);-（方法内））就行（JVM自动了）；
  • try…catch中常用Throwable的三个方法，getMessage（简短）,toString（详细）,printStackTrace（JVM默认，无返回值）
  • finally—不管有没有异常都执行，和try一起用
  • 父类异常什么样，子类就一样
  • 自定义异常我就看继承的是Exception（编译期）还是RuntimeException（运行期）
  • 多线程：就是为了提高CPU使用效率
  • 并发（交叉执行），并行（同步），线程（执行路径），进程（进到内存的程序），分时调度（平均分配线程时间），抢占式调度（看线程优先级，没有就随机）
  • 主线程：执行main方法的线程（从上到下执行）
  • 多线程实现方式一：（1）继承Thread然后重写run方法（线程任务），（2）创建Thread类子类对象，执行start方法来执行run方法（一个线程只能调用异常）
狂野小白兔
发布了42 篇原创文章 · 获赞 6 · 访问量 1134
私信 关注

猜你喜欢

转载自blog.csdn.net/qq_40572023/article/details/104639711
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
周排行
让自己的头脑极度开放
CentOS 6.5(x64) 和Redhat6.5操作系误删libc
高可用注册中心
【日记】12.28/【题解】AtCoder AGC041
XML（5）_XML 约束_DTD
Java集合Map（四）
树梅派安装桌面环境教程
pipenv 的 使用和安装
小程序白屏问题和内存研究
C语言简单选择排序
每日归档
更多
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022