Java学习篇21_异常、线程

上一篇博客：

---

目录

• 异常
  • 异常介绍
  • 异常的处理
  • 自定义异常
• 多线程
  • 并发与并行
  • 线程与进程
  • 创建线程类

开始

---

异常

一、异常介绍

1.1 异常就是不正常的意思，在程序中就是：

程序在执行过程中，出现的非正常情况，最终导致JVM的非正常停止

1.2 在Java等面向对象的编程语言中：

异常本身就是一个类

产生异常就是就是创建异常对象并抛出

Java处理异常的方式是中断处理

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

1.3 异常体系

异常机制是帮助我们找到程序中的问题，异常的根类是java.lang.Throwable，其下有两个子类

• java.langError
• java.lang.Exception：平常所说的异常

Throwable体系：

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

Throwable中常用方法：

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

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

• public String getMessage():获取发生异常的原因。

  提示给用户的时候,就提示错误原因。

• public String toString():获取异常的类型和异常描述信息(不用)。

1.4 异常分类

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

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

1.5 异常的产生过程解析

package Demo_21;

public class Demo_01_ArrayTools {
    public static int getElement(int[] arr,int index){
        int element  = arr[index];
        return element;
    }
}

package Demo_21;

public class Demo_01_Exception {
    public static void main(String[] args) {
        int[] arr = {2,55,994};
        int num = Demo_01_ArrayTools.getElement(arr,4);
        //报错java.lang.ArrayIndexOutOfBoundsException: Index 4 out of bounds for length 3
        System.out.println("num = "+ num);
        System.out.println("over");
    }


}

二、异常的处理

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

2.1 抛出异常

编写程序时，我们必须考虑程序出现问题的情况，比如传错误类型的参数 给接受参数的方法时，需要对参数数据进行合法的判断

若数据不合法，就应该使用抛出异常的方法告诉调用者

在java中，throw关键字来抛出一个指定的异常对象，步骤：

1. 创建一个异常对象。封装一些自定义提示信息
2. throw 异常对象—》用在方法内，抛出异常对象或者将这个异常对象传递到调用者出，结束执行

• 使用格式：throw new 异常类名(参数);

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

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

• 举栗：

package Demo_21;

public class Demo_01_ArrayTools {
    public static int getElement(int[] arr,int index){

        if(index < 0 || index > arr.length-1){
            throw new ArrayIndexOutOfBoundsException("小笨蛋~超出索引范围了~");
        }
        int element  = arr[index];
        return element;
    }
}

package Demo_21;

public class Demo_01_Exception {
    public static void main(String[] args) {
        int[] arr = {2,55,994};
        int num = Demo_01_ArrayTools.getElement(arr,4);
        //报错java.lang.ArrayIndexOutOfBoundsException: Index 4 out of bounds for length 3
        System.out.println("num = "+ num);
        System.out.println("over");
    }


}

• 注意：

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

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

2.2 Objects非空判断

前面学习的Objects类有一些静态的实用方法，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的）

原因是在他的源代码中，对对象的null值进行了抛出异常处理

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

2.3 声明异常throws

声明异常：将问题标识出来，报告给调用者

如果方法内部通过throw抛出了编译时异常，而没有try…catch捕获处理，那么必须通过throws进行声明，让调用者去处理

关键字throws运用于方法声明之上， 用于表示当前方法不处理异常，而是告诉调用者来处理异常（抛出异常）

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

package Demo_21;

import java.io.FileNotFoundException;

public class Demo_02_TestMain {
    //read方法的调用者 也需要throws声明
    public static void main(String[] args) throws FileNotFoundException {

        read("b.txt");
    }

    //方法内throw抛出异常，而么有try catch，就要在方法后throws声明
    private static void read(String path) throws FileNotFoundException {
        if(! path.equals("a.txt")){
            throw new FileNotFoundException("文件不存在");
        }
    }

}

package Demo_21;

import java.io.FileNotFoundException;
import java.io.IOError;
import java.io.IOException;

public class Demo_02_TestMain {
    //read方法的调用者 也需要throws声明,声明一个大的父类即可
    public static void main(String[] args) throws IOException {

        read("c.txt");
    }

    //方法内throw抛出异常，而么有try catch，就要在方法后throws声明
    private static void read(String path) throws IOException {
        if(! path.equals("a.txt")){
            throw new FileNotFoundException("文件不存在");
        }
        if(! path.equals("b.txt"));{
            throw new IOException();
        }
    }


}

2.4 捕获异常try…catch

如果异常出现，会立即终止程序，我们需要处理异常：

• throws—>该方法不处理，而是声明抛出，由该方法的调用者来处理
• try…catch—>在方法中使用try-catch的语句块来处理异常

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

语法：

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

举栗：

package Demo_21;

import java.io.FileNotFoundException;

public class Demo_03_TestMain {
    public static void main(String[] args) {
        try {
            //当产生异常时，必须有处理方式
            read("b.txt");
        } catch(FileNotFoundException e){
            //try中抛出什么异常，在括号里就定义什么异常类型
            //尝试try的代码块，如果是异常就catch住
            System.out.println(e);
        }

        System.out.println("over");
    }

    //我们 当前的这个方法中 有异常 有编译器异常

    private static void read(String path) throws FileNotFoundException {
        //如果不是a.txt，就是一个异常
        if(! path.equals("a.txt")){
            throw new FileNotFoundException("文件不存在");
        }


    }
}

如何获异常信息：

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

• public String getMessage():获取异常值的描述信息、原因
• public String toString():获取异常的类型和异常描述信息（不常用）
• public void printStackTrace():打印异常的跟踪信息并输出到控制台（常用）

2.4 finally代码块

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

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

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

finally语法：

try…catch…finally

注意：finall不能单独使用

举栗：

package Demo_21;

import java.io.FileNotFoundException;

public class Demo_04_TestMainFinally {
    public static void main(String[] args) {
        try{
            read("a.txt");
        } catch(FileNotFoundException e){
            //抓的是编译期异常 抛出去的是运行期
            throw new RuntimeException(e);

        } finally {
            System.out.println("不管程序怎样，这里都会被执行");
        }
        System.out.println("over");
    }


    //我们当前方法中有异常 有编译器异常
    private static void read(String path) throws FileNotFoundException {
        if(! path.equals("c.txt")){
            throw new FileNotFoundException();
        }
    }
}

2.5 异常注意事项

多个异常使用捕获

• 多个异常分别处理
• 多个异常一次捕获，多次处理（一般这样）
• 多个异常一次捕获一次处理

try{
     编写可能会出现异常的代码
}catch(异常类型A  e){  当try中出现A类型异常,就用该catch来捕获.
     处理异常的代码
     //记录日志/打印异常信息/继续抛出异常
}catch(异常类型B  e){  当try中出现B类型异常,就用该catch来捕获.
     处理异常的代码
     //记录日志/打印异常信息/继续抛出异常
}

注意:

1. 这种异常处理方式，要求多个catch中的异常不能相同，并且若catch中的多个异常之间有子父类异常的关系，那么子类异常要求在上面的catch处理，父类异常在下面的catch处理。
2. 运行时被抛出可以不处理，即不捕获也不声明抛出
3. 如果finally有return语句，永远返回finally中的结果避免该情况
4. 如果父类抛出多个异常，子类重写父类方法时，抛出和父类相同的异常或者是父类异常的子类或者不抛出异常
5. 父类方法没有抛出异常，子类重写父类该方法时可以不抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出。

三、自定义异常

3.1 概述

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

出现自定义的需求，就要定义自定义的异常类

什么是自定义异常类：

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

自定义一个业务逻辑异常：RegisterException—》一个注册异常类

异常类如何定义：

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

3.2 自定义异常的练习

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

package Demo_21;

//业务逻辑异常
public class RegisterException extends Exception{
    public RegisterException() {
        //空参构造
    }

//@param message 表示异常提示
    public RegisterException(String message){
        super(message);
    }
}

package Demo_21;

import javax.security.auth.login.LoginException;

public class Demo_RegisterExceptionTest  {
    private static String[] names = {"xiaosi","xiao","si"};
    //模拟登陆操作，使用数组模拟数据库中存储的数据，并提供当前注册账号是否存在方法用于判断。


    public static void main(String[] args) {
        try{
            checkUserName("xiaosi");
            System.out.println("注册成功~");
        } catch(RegisterException e){
        //处理异常
            e.printStackTrace();
        }
    }

    private static boolean checkUserName(String uname) throws RegisterException{
            for(String name : names){
                if(name.equals(uname)){
                    throw new RegisterException("你太慢了~你的id: " + uname +"早都被人注册了");

                }

            }
            return true;
        }
}

四、多线程

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

4.1 并发与并行

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

在操作系统中，安装了多个程序

并发：

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

而在多CPU的系统中，这些并发执行的程序便可以分配到多个处理器（CPU）上，实现多任务并行执行

这样多个CPU可以同时运行多个程序，多核处理器，核越多，并行处理的程序越多，能大大的提高电脑运行的效率。

注意：

单核处理器的计算机是不能并行处理多任务的（可以理解一个人不能同时在不同场地干不同的活）

只能是多个任务在单个CPU上并发运行（可以理解是一个人可在一段时间中交替干两件事）

同理,线程也是一样的，从宏观角度上理解线程是并行运行的，但是从微观角度上分析却是串行并发运行的，即一个线程一个线程的去运行，当系统只有一个CPU时，线程会以某种顺序执行多个线程，我们把这种情况称之为线程调度。

多程序—》多进程—》不同线程之间执行的时候按照优先级去一个个执行

4.2 线程与进程

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

• 线程：
  线程是进程中的一个执行单元，负责当前进程中程序的执行
  一个进程中至少有一个线程
  一个进程中有多个线程时，这个应用程序称为 多线程程序

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

任务管理器查看任务的进程，每一行都是一个进程

线程

线程调度：

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

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

  设置线程的优先级：
  
  抢占式调度详解：

大多数操作系统都支持多进程并发运行，现在的操作系统几乎都支持同时运行多个程序

好似同一时刻运行

实际上

CPU（中央处理器）使用的抢占式调度模式在镀铬线程间高速的切换（一个人在两个工作间跑的够快，就会被认为有两个人在同时工作）

对于CPU的一个核而言，某个时刻，只能执行一个线程

其实

多线程并不能提高程序的运行速度，但是能提高程序运行效率，让CPU的使用率更高

4.3 创建线程类

Java使用java.lang.Thread类代表线程

所有的线程对象都必须是Thread类或其子类的实例。

每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。

Java使用线程执行体来代表这段程序流。Java中通过继承Thread类来创建并启动多线程的步骤如下：

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

举栗：

package Demo_21;

public class MyThread extends Thread{

    //定义指定线程名称的构造方法
    public MyThread(String name) {
        //调用父类的String参数的构造方法，指定线程的名称
        super(name);
    }

    @Override
    //重写run方法
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName() + " 正在执行！ " + i);
        }
    }
}

package Demo_21;

public class Demo_05_ThreadTest {
    public static void main(String[] args) {
        
        //创建自定义线程对象

        MyThread mt = new MyThread("新的线程");
        
        //开启新线程

        mt.start();
        //在主方法中执行for循环
        for (int i = 0; i < 10; i++) {
            System.out.println("main线程 "+ i);
        }

    }
}

---

参考：B站黑马