02_05_Java语音进阶||day05_异常，异常的处理，自定义异常，线程【并发与并行】

原创

狂野小白兔 2023-02-26 18:54:06 博主文章分类：笔记 ©著作权

文章标签 java System 数组 文章分类 JavaScript 前端开发

©著作权归作者所有：来自51CTO博客作者狂野小白兔的原创作品，请联系作者获取转载授权，否则将追究法律责任

第一章异常

1.1 异常概念

异常：就是不正常的意思（字面）
异常：指的是程序在执行过程中，出现的非正常情况，最终会导致JVM的非正常停止。
在Java中，异常本身就是一个类，产生异常就是创建异常对象并抛出了一个异常对象。Java的处理方式是中断处理

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

1.2 异常体系

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

02_05_Java语音进阶||day05_异常，异常的处理，自定义异常，线程【并发与并行】_数组

2. Throwable体系：

* Error：严重错误Error，无法通过处理的错误，只能事先避让，比如：绝症

* Exception：表示异常，异常产生后程序员可以通过代码的方式纠正，使程序继续运行，是必须要处理的，比如：感冒，阑尾炎

* 注：留意一下RuntimeExcepition（Exception子类）：运行期间抛出的异常

1.3 异常分类

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

Exception:编译期异常【!】,进行编译(写代码)java程序出现的问题——我们就必须处理这个异常，要么throws或者try…catch【重点】

RuntimeException:运行期异常【!】,java程序运行过程中出现的问题——我们不用处理，交给JVM处理【重点】
异常就相当于程序得了一个小毛病(感冒,发烧),把异常处理掉,程序可以继续执行(吃点药,继续革命工作)

Error:错误

错误就相当于程序得了一个无法治愈的毛病(非典,艾滋).必须修改源代码,程序才能继续执行

处理异常方式：

虚拟机处理异常
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 异常的产生过程解析

02_05_Java语音进阶||day05_异常，异常的处理，自定义异常，线程【并发与并行】_System_02

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

第二章异常的处理

2.1 抛出异常throw

Java异常处理的五个关键字【重点】：try,catch,finally,throw,throws

throw关键字：

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

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

    //例：
    if () { //方法传递过来的参数进行合法性校验
        throw new xxxException("异常产生的原因");
    }

注意事项：

throw关键字必须写在方法的内部
throw关键字后面new的对象必须是Exception或者Exception的子类对象
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非空判断

Objects类中的静态方法（JDK1.7工具类）
public static T requireNonNull(T obj):查看指定引用对象不是null。

也可以(obj, “异常信息”);

源码:

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

发现和2.1中是否为null的合理性校验类似

if(arr == null){
            throw new NullPointerException("传递数组的值是null");
    }

所以我们可以把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");
        }
    }

作用：

Objects.requireNonNull方法的作用就是简化，方法合法性校验中空指针异常代码的书写

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

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

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

使用格式:在方法声明时使用【!】

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

注意事项:

throws关键字必须写在方法声明处
throws关键字后边声明的异常必须是Exception或者是Exception的子类
方法内部如果抛出了多个异常对象,那么throws后边必须也声明多个异常

如果抛出的多个异常对象,有子父类关系,那么直接声明父类异常即可【!】

调用了一个声明抛出异常的方法,我们就必须的处理声明的异常【重点】

要么继续使用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—异常处理的第二种方式（自己处理异常）

声明异常throws的缺点：

使用声明异常throws之后，如果抛出异常时候，后面还有代码就不在执行【!】–>程序就停了

因为最终交给JVM处理–>中断处理

try…catch:异常处理的第二种方式,自己处理异常

在抛出异常的时候还能执行后面的程序【!】

格式:

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

    }
    
    //例子：
    try{
        readFile("d:\\a.txt");
    }catch (IOException e){
        System.out.println("catch - 传递的文件后缀不是.txt");
    }

注：try中抛出什么异常对象,catch就定义什么异常变量,用来接收这个异常对象

注意事项:

try中可能会抛出多个异常对象,那么就可以使用多个catch来处理这些异常对象
如果try中++产生++了异常【!】,那么就会执行catch中的异常处理逻辑,执行完毕catch中的处理逻辑,继续执行try…catch之后的代码
如果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个异常处理的方法

String getMessage()

返回此 throwable 的简短描述。

try{
        readFile("d:\\a.tx");
    }catch (IOException e){
        System.out.println(e.getMessage()); //文件的后缀名不对
    }

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: 文件的后缀名不对
    }

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代码块

finally:有一些特点的代码无论异常是否发生，都需要执行。

比如try中异常对象如果发生异常就不会执行try中下面的代码

finally代码块
格式:

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

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

注意实现:

finally不能单独使用,必须和try一起使用
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 异常的注意事项—多异常的捕获处理

多个异常使用捕获又该如何处理呢？

多个异常分别处理。

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);
    }

多个异常一次捕获，多次处理。

一个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);
    }

02_05_Java语音进阶||day05_异常，异常的处理，自定义异常，线程【并发与并行】_System_03

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中异常都包含即可
注意事项：

运行时异常被抛出可以不处理

即不捕获也不声明抛出
默认给虚拟机处理,终止程序,什么时候不抛出运行时异常了,在来继续执行程序

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

如果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 异常的注意事项—子父类异常

子父类的异常:

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

注意事项:

父类异常时什么样,子类异常就什么样【总结】

注：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 概述

自定义异常类:

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

格式:

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

注：添加一个带异常信息的构造方法

查看源码发现,所有的异常类都会有一个带异常信息的构造方法,
方法内部会调用父类带异常信息的构造方法,让父类来处理这个异常信息

注：同上，空参方法要调用父类的空参构造方法

public class RegisterException extends Exception{
        //空参方法要调用==父类的空参构造方法
        public RegisterException(){
            super();
        }
    
        //添加一个带异常信息的构造方法
        //方法内部会==调用父类==带异常信息的构造方法,==让父类来处理这个异常信息==
        public RegisterException(String message){
            super(message);
        }
    }

注意事项：

自定义异常类一般都是以Exception结尾,说明该类是一个异常类
自定义异常类,必须的继承Exception或者RuntimeException

继承Exception:那么自定义的异常类就是一个编译期异常,如果方法内部抛出了编译期异常,就必须处理这个异常,要么throws,要么try…catch
继承RuntimeException:那么自定义的异常类就是一个运行期异常,无需处理,交给虚拟机处理(中断处理)

3.2 自定义异常练习

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

使用数组保存已经注册过的用户名(数据库)
使用Scanner获取用户输入的注册的用户名(前端,页面)
定义一个方法,对用户输入的中注册的用户名进行判断

遍历存储已经注册过用户名的数组,获取每一个用户名
使用获取到的用户名和用户输入的用户名比较

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 并发与并行

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

交替执行【!】

并行：值两个或多个事件在同一时刻发生

同时执行【!】

4.2 线程与进程—进程概念

进程：进入到内存的程序（每个打开的软件就是一个进程）

点击应用程序执行，进入到内存中，占用一些内存执行

关闭进程：

任务管理器–>结束进程（那么就把进程从内存中清除了）

注：

永久存储ROM：硬盘
临时存储RAM：内存（所有的应用程序都需要进入到内存中执行）

02_05_Java语音进阶||day05_异常，异常的处理，自定义异常，线程【并发与并行】_System_04

4.3 线程与进程—线程概念

CPU：中央处理器

对数据进行计算，指挥电脑中软件和硬件干活

CPU的分类：

AMD
Inter

Inter Core(核心) i7 8866 4核心8线程
8线程：同时执行8个任务

线程举例：各种杀毒软件（是一个进程）中同时进行不同功能
线程概念引入：

点击杀毒软件功能（病毒查杀，清理垃圾，电脑加速）执行
就会开启一条应用程序到cpu的执行路径
cpu就可以通过这个路径执行功能
这个路径有一个名字，叫线程（通向cpu的执行路径）

线程属于进程【!】

是进程中的一个执行单元，负责程序的执行。

单核心单线程cpu—执行多线程功能

cpu在多个线程之间做高速的切换
轮流执行多个线程
效率低
切换的速度（1/n毫秒）

4核心8线程cpu—执行多线程功能

有8个线程：可以同时执行8个线程
8个线程在多个任务之间做高速的切换
速度是单线程的8倍（每个任务被执行的几率都提高了8倍）

多线程的好处：

效率高
多个线程之间互不影响

02_05_Java语音进阶||day05_异常，异常的处理，自定义异常，线程【并发与并行】_java_05

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

对于CPU的核而言，某个时刻，只能执行一个线程。而CPU多线程的切换速度相对较快，看上去就像同时在执行【!】
其实：多线程程序并不能提高程序的运行速度，但能提高程序运行效率，让CPU的使用率更高【重点】

分时调度：

所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间
比如4.3中有杀毒软件有三个线程，系统分配杀毒软件执行时间9秒，则每个线程3秒钟。

抢占式调度：

优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个（线程随机性）

Java使用的为抢占式调度

设置线程的优先级：(win10在详细信息中)

抢占式调度详解：

4.5 主线程

主线程:执行主(main)方法的线程

单线程程序:java程序中只有一个线程
执行从main方法开始,从上到下依次执行

单线程的弊端：

当程序中间抛出异常，则中断程序后，后面就不能执行了

02_05_Java语音进阶||day05_异常，异常的处理，自定义异常，线程【并发与并行】_java_06

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

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

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

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

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

实现步骤:

创建一个Thread类的子类(继承Thread)
在Thread类的子类中重写Thread类中的run方法,设置线程任务(开启线程要做什么?)
创建Thread类的子类【!】对象
调用Thread类中的方法start方法,开启新的线程,来执行run方法

void start()

使该线程开始执行；Java 虚拟机调用该线程的 run 方法。

结果是两个线程并发地运行；当前线程（main线程）和另一个线程（创建的新线程,执行其 run 方法）。
一个线程只能调用唯一一次，多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启动。

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方法（一个线程只能调用异常）

上一篇：01_08_Java语言入门||02_面向对象与常用类||day08_String类，static，Arrays类，Math类

下一篇：01_11_Java语言入门||02_面向对象与常用类||day11_final、权限、内部类、成员变量类型和方法的参数及返回值特例

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯