学习JavaEE的日子 Day28 异常，多线程

A 北枝

已于 2024-07-20 11:38:33 修改

阅读量960

点赞数 38

分类专栏：学习JavaEE 文章标签： python 开发语言多线程异常

于 2024-03-21 09:45:09 首次发布

本文链接：https://blog.csdn.net/weixin_69595694/article/details/136897833

版权

学习JavaEE 专栏收录该内容

55 篇文章 1 订阅

订阅专栏

Day28

1.异常机制

1.1 异常概念

异常是程序在运行期发生的不正常的事件，它会打断指令的正常执行流程。

设计良好的程序应该在异常发生时提供处理这些不正常事件的方法，使程序不会因为异常的发生而阻断或产生不可预见的结果。

Java语言使用异常处理机制为程序提供了异常处理的能力

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

在这里插入图片描述

1.2 异常分类

Java程序运行过程中所发生的异常事件从严重性可分为两类：

1、错误(Error)：JVM系统内部错误或资源耗尽等严重情况－属于JVM需要负担的责任这一类异常事件无法恢复或不可能捕获，将导致应用程序中断。

2、异常(Exception)：其它因编程错误或偶然的外在因素导致的一般性问题。这类异常得到恰当的处理时，程序有机会恢复至正常运行状况。

在这里插入图片描述

1.2.1 错误出现的情况

错误(Error)：JVM系统内部错误或资源耗尽等严重情况，属于JVM需要负担的责任，这一类异常事件无法恢复或不可能捕获，将导致应用程序中断。

错误Error，无法通过处理的错误，只能事先避免，好比绝症。

public class Test01 {
	public static void main(String[] args) {
		
		//StackOverflowError - 栈内存溢出的错误
		//出现原因：调用方法会在栈中开辟空间，用于存放该方法的局部变量，死循环的调用方法，栈内存就满载并溢出了
		method();
	}
	
	public static void method(){
		method();
	}
}

public class Test02 {
	public static void main(String[] args) {
		
		//OutOfMemoryError -- 内存溢出的错误
		//出现原因：new出来的数组添加到集合中，该数组不会被回收
		ArrayList<byte[]> list = new ArrayList<>();
		while(true){
			byte[] bs = new byte[8192];
			list.add(bs);
		}		
		
	}
}

什么情况下会发生Error

1.JVM内部错误

2.资源耗尽的情况（一定要举例，会吹）

 案例1：
public static void method(){
	method();
 }

案例2：
ArrayList<Object> list = new ArrayList<>();
while(true){
	Object obj = new Object();
	list.add(obj);
 }

案例3：
String[] names = new String[1200000000];

1.2.2 异常出现的情况

异常(Exception)：因编程错误或偶然的外在因素导致的一般性问题。

这类异常得到恰当的处理时，程序有机会恢复至正常运行状况。

分类：

RuntimeException – 非受检性异常

一般性异常 --------- 受检性异常

非受检性异常

RuntimeException（非受检性异常）：

编译器不要求强制处置的异常。一般是指编程时的逻辑错误。是程序员应该积极避免其出现的异常。

注意：java.lang.RuntimeException及它的子类都是非受检异常

错误的类型转换：java.lang.ClassCastException

数组下标越界：java.lang.ArrayIndexOutOfBoundsException

空指针访问：java.lang.NullPointerException

算术异常(除0溢出)：java.lang.ArithmeticException

public class Test03 {
	public static void main(String[] args) {
		
		//ArithmeticException -- 算数异常
		System.out.println(10/0);
		
        //ArrayIndexOutOfBoundsException -- 数组下标越界异常
		int[] arr = {1,2,3};
		System.out.println(arr[1000]);
        
        //IndexOutOfBoundsException - 下标越界异常
		ArrayList<Object> list = new  ArrayList<>();
		System.out.println(list.get(100));
        
        //ClassCastException - 类型转换异常
		Object obj = new Integer(100);
		String str = (String) obj;
		System.out.println(str);
        
        //NullPointerException --空指针异常
		String str = null;
		method(str);
        
	}
    	public static void method(String str) {
		System.out.println(str.length());
	}

}

解决方案：

		//减少类型转型异常 - 解决方案1：
//		Object obj = new String("用良心做教育");
//		if(obj instanceof String){
//			String str = (String) obj;
//			System.out.println(str);
//		}
//		if(obj instanceof Integer){
//			Integer i = (Integer) obj;
//			System.out.println(i);
//		}
		
		//减少类型转型异常 - 解决方案2：
		Object obj = new String("用良心做教育");
		if(obj != null && obj.getClass() == String.class){
			String str = (String) obj;
			System.out.println(str);
		}
		if(obj != null && obj.getClass() == Integer.class){
			Integer i = (Integer) obj;
			System.out.println(i);
		}

受检性异常

一般性异常（受检性异常）：编译器要求必须处置的异常。指的是程序在运行时由于外界因素造成的一般性异常。

没有找到指定名称的类：java.lang.ClassNotFoundException

访问不存在的文件：java.io.FileNotFoundException

操作文件时发生的异常：java.io.IOException

操作数据库时发生的异常：java.sql.SQLException

public class Test08 {
	public static void main(String[] args) throws ClassNotFoundException {	
		
		//ClassNotFoundException -- 类未找到异常
		Class<?> clazz = Class.forName("java.lang.String111111");
		System.out.println(clazz);
        
        //FileNotFoundException - 文件未找到异常
		FileInputStream fis = new FileInputStream("C:\\Users\\Desktop\\异常理解图.png");
		System.out.println(fis);
	}

}

1.3 Java的异常处理机制(面试题)

1.Java程序在执行过程中如果出现异常，会自动生成一个异常类对象，该异常对象将被自动提交给JVM，这个过程称为抛出(throw)异常。

2.当JVM接收到异常对象时，会寻找能处理这一异常的代码

3.1 找到了 - 把当前异常对象交给其处理，这一过程称为捕获(catch)异常和处理异常。

3.2 没找到 - 运行时系统将终止，相应的Java程序也将退出。

1.4 Java处理异常的能力

1.try…catch…

2.throws

3.throw

1.4.1 try…catch…

语法结构：

try{

… //可能产生异常的代码

}catch( ExceptionName1 e ){

… //异常的处理代码

}catch( ExceptionName2 e ){

… //异常的处理代码

} finally{

… //无论如何都会执行的语句

}

理解：

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

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

场景：处理一个异常的情况

public class Test01 {		
	public static void main(String[] args) {
		
		Scanner scan = new Scanner(System.in);
		
		System.out.println("请输入一个数字：");
		int a = scan.nextInt();
		System.out.println("请输入第二个数字：");
		int b = scan.nextInt();
		
		try{
			System.out.println("111");
			System.out.println(a/b);
			System.out.println("222");
			
		}catch (ArithmeticException e) {
			System.out.println("处理算数异常");
		}finally {
			scan.close();
		}
		
	}		
}

场景：处理多个异常，但处理方式不一样的情况

注意：

1.finally代码块根据需求可写可不写

2.经验告诉我们关闭资源的代码一般写在finally

3.try…catch…可以有多个catch

4.try 代码段包含的是可能产生异常的代码

5.先捕获的异常范围不能大于后捕获的异常范围

6.当异常发生时，程序会中止当前的流程去执行相应的catch代码段。

7.finally段的代码无论是否发生异常，都执行

public class Test02 {
	public static void main(String[] args) {
		
		Scanner scan = new Scanner(System.in);
		
		System.out.println("请输入一个数字：");
		int a = scan.nextInt();
		System.out.println("请输入第二个数字：");
		int b = scan.nextInt();
		System.out.println("请输入类的全路径：");
		String classPath = scan.next();
		
		try{
			System.out.println("111");
			System.out.println(a/b);
			System.out.println("222");
			
			Class<?> clazz = Class.forName(classPath);
			System.out.println(clazz.getName());
			
			System.out.println("333");
			
		}catch (ArithmeticException e) {
			System.out.println("处理算数异常");
			
		}catch (ClassNotFoundException e){
			System.out.println("处理类未找到异常");
			
		}finally {
			scan.close();
		}
		
	}
		
}

1.4.2 throws

在定义一个方法的时候可以使用throws关键字声明，使用throws声明的方法表示此方法不处理异常，而交给方法的调用方进行处理。

1.本身的程序处理不了了，往上一层抛，由上一层去处理

2.定义一个方法的时候，通过这种方式来告知调用方，我这个方法有可能会发生异常的。

语法结构：

public void method() throws 异常1,异常2{}

理解：

throws是抛出异常，抛给方法的调用方，一层一层往上面抛，最后try…catch…处理

注意：此时抛出的是异常类型，并且抛出的异常类型是紧跟在方法名之后。

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

public class Test01 {
	public static void main(String[] args) {

		try {
			method01();
		} catch (ClassNotFoundException e) {
			System.out.println("处理异常");
		}

	}

	public static void method01() throws ClassNotFoundException{
		method02();
	}

	public static void method02() throws ClassNotFoundException{
		method03();
	}

	public static void method03() throws ClassNotFoundException{
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入类的全路径：");
		String classPath = scan.next();
		
		Class<?> clazz = Class.forName(classPath);
		System.out.println(clazz.getName());
		
		scan.close();
	}
}

1.4.3 throw

异常不仅仅虚拟机可以抛，我们自己也可以抛。我们可以在代码中使用throw关键字(注意不带s)来抛出某个具体的异常对象。很多情况下我们会手动抛出运行时异常。

语法结构：

throw new 异常(); //抛给自己写的异常类

throw new NullPointerException(“要访问的arr数组不存在”); //直接解决，不用创建异常类

理解：

手动抛出异常—throw new RuntimeException(“程序出现了异常”);

throw 结合自定义异常使用(自己写一个异常类)

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

注意：

只要catch语句块中没有return和throw语句，就会继续执行try-catch-finally之外的代码，所谓的遇到异常就不执行了，说的是try语句块中的代码。

public class Test01 {
	public static void main(String[] args) {

		Scanner scan = new Scanner(System.in);
		
		System.out.println("请输入一个数字：");
		int a = scan.nextInt();
		System.out.println("请输入第二个数字：");
		int b = scan.nextInt();
		
		try {
			if(b == 0){
				throw new MyException(); 
                //throw new Exception("XXXX");
			}
		} catch (MyException e) { //这里也要写自己写的异常类 或者 Exception e
			b = 1;
			System.out.println(e);
		}
		
		System.out.println(a/b);
		
		scan.close();
	}
}

创建自定义异常，需要继承Exception 或其子类。

public class MyException extends Exception{

	@Override
	public String toString() {
		return "除数不能为0的异常";
	}
}

多线程

1.什么是进程

进程是系统进行资源分配和调用的独立单元，每一个进程都有它的独立内存空间和系统资源。

2.单进程操作系统和多进程操作系统的区别

单进程操作系统：dos（一瞬间只能执行一个任务）

多进程单用户操作系统：Windows（一瞬间只能执行多个任务）

多进程多用户操作系统：Linux（一瞬间只能执行多个任务）

3.现在的多核CPU是否可以让系统在同一个时刻可以执行多个任务吗？

理论上是可以的

4.什么是线程，理解线程和进程的关系

什么是线程？

线程是进程里面的一条执行路径，每个线程同享进程里面的内存空间和系统资源

一个进程可以有多个线程：各个线程都有不同的分工

理解线程和进程的关系

进程与进程之间的关系：进程之间的内存空间和系统资源是独立的

同一个进程里的多条线程：线程之间的内存空间和系统资源是共享的

进程里：可以有一条或一条以上的线程

进程里只有一条线程的情况下，这条线程就叫做主线程

进程里有多条线程的情况下，只有一条线程叫做主线程

Ps：线程是在进程里的，他们是包含关系

5.我们应用的软件有哪些是多线程的应用？

都是

6.Java中，如何来编写多线程的应用程序？有哪些方法

6.1 创建线程 – 线程类（继承Thread类）

步骤：

1.创建线程类（MyThread），继承Thread，重写run方法

2.创建子线程 – MyThread t = new MyThread();

3.启动线程 ---- t.start();

public class Test01 {
	public static void main(String[] args) {
		
		//创建子线程
		MyThread t = new MyThread();
		
		//启动子线程
		t.start();
	}
}

public class MyThread extends Thread{

	//该线程的对象抢到CPU资源后，才会调用run方法
	@Override
	public void run() {
		System.out.println("MyThread类中的run方法被调用了");
	}
}

void run() :在线程开启后，此方法将被调用执行

void start() :使此线程开始执行，Java虚拟机会调用run方法()

- run()方法和start()方法的区别？

run()：封装线程执行的代码，直接调用，相当于普通方法的调用

start()：启动线程；然后由JVM调用此线程的run()方法

用start方法才能真正启动线程，此时线程会处于就绪状态，一旦得到时间片，则会调用线程的run方法进入运行状态。
而run方法只是普通方法，如果直接调用run方法，程序只会按照顺序执行主线程这一个线程。

6.2 创建线程 – 任务类（实现Runnable接口）

步骤：

1.创建任务类（Task），实现Runnable接口中的run方法

2.创建任务类对象 – Task task = new Task();

3.创建子线程，并把任务交给他 – Thread t = new Thread(task);

4.启动线程 – t.start();

public class Test01 {
	public static void main(String[] args) {
		
		//创建任务类对象
		Task task = new Task();
		
		//创建子线程，并把任务交给他
		Thread t = new Thread(task);
		
		//启动线程
		t.start();
	}
}

public class Task implements Runnable{

	//线程对象抢到CPU资源后才会调用run方法
	@Override
	public void run() {
		System.out.println("Task类中的run方法被调用了");
	}

}

3.带返回值的任务类

4.线程池

七、感受多线程之间争抢资源的场景

需求：编写一个多线程的应用程序，主线程打印1-100之间的数字，子线程打印200-300之间的数字，观察其输出的结果，体会多线程互相争抢资源的场景

public class Test01 {
	public static void main(String[] args) {
		
		MyThread t = new MyThread();
		t.start();
		
		for (int i = 1; i <= 100; i++) {
			System.out.println("主线程：" + i);
		}
	}
}

public class MyThread extends Thread{

	@Override
	public void run() {
		for (int i = 200; i <= 300; i++) {
			System.out.println("子线程：" + i);
		}
	}
}

八、小结

进程与进程的关系：独享内存空间和系统资源

线程与进程的关系：一个进程中至少包含一个线程

线程与线程的关系：在同一个进程里，多个线程共享内存空间和系统资源

一个进程中包含多个线程，只有一个主线程

经典面试题：请问当我们编写一个单纯的main方法时，此时该程序是否为单线程的？为什么？

不是，是多线程，因为还有垃圾回收器

垃圾回收器是一个后台线程

九、线程的优先级别

含义：给线程定义抢到CPU资源的优先级

理解：

1.优先级别：1~10，数字越大，优先级越高

2.线程的优先级别不能决定线程是否优先抢到资源，优先级别只能影响（概率问题）

需求：在主线程中创3个子线程，并且设置不同优先级，观察其优先级对线程执行结果的”影响”。

a.setPriority(Thread.MAX_PRIORITY);//10
b.setPriority(Thread.NORM_PRIORITY);//5 — 默认的
c.setPriority(Thread.MIN_PRIORITY);//1

final int getPriority()：返回此线程的优先级

final void setPriority(int newPriority)：更改此线程的优先级线程默认优先级是5；线程优先级的范围是：1-10

public class Test01 {
	public static void main(String[] args) {
		
		A a = new A();
		B b = new B();
		C c = new C();
		
		//设置优先级别 --- a抢到资源的概率大一点，c小一点
		a.setPriority(Thread.MAX_PRIORITY);//10
		b.setPriority(Thread.NORM_PRIORITY);//5
		c.setPriority(Thread.MIN_PRIORITY);//1
		
		a.start();
		b.start();
		c.start();
		
	}
}

public class A extends Thread{

	@Override
	public void run() {
		for (int i = 1; i <= 100; i++) {
			System.out.println("A：" + i);
		}
	}
}

public class B extends Thread{

	@Override
	public void run() {
		for (int i = 1; i <= 100; i++) {
			System.out.println("B：" + i);
		}
	}
}

public class C extends Thread{

	@Override
	public void run() {
		for (int i = 1; i <= 100; i++) {
			System.out.println("C：" + i);
		}
	}
}

- 线程调度

- 两种调度方式

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

- 抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些

- Java使用的是抢占式调度模型

十、给线程自定义名称

自己写getThreadName/setThreadName
调用父类的一个参数的构造方法和getName
Thread.currentThread().getName()

有多个类，有相同的功能，就可以不用一个一个创建类，直接创一个MyThread类，有参构造传参就可以了

需求：在主线程中创3个子线程，并且设置不同优先级，观察其优先级对线程执行结果的”影响”。

public class Test01 {
	public static void main(String[] args) {
		
		MyThread a = new MyThread("A");
		MyThread b = new MyThread("B");
		MyThread c = new MyThread("C");
		
		//设置优先级别
		a.setPriority(Thread.MAX_PRIORITY);//10
		b.setPriority(Thread.NORM_PRIORITY);//5
		c.setPriority(Thread.MIN_PRIORITY);//1
		
		a.start();
		b.start();
		c.start();
		
	}
}

public class MyThread extends Thread{
	
	private String threadName;
	
	public MyThread(String threadName) {  //有参构造
		this.threadName = threadName;
	}

	@Override
	public void run() {
		for (int i = 1; i <= 100; i++) {
			System.out.println(threadName + "：" + i);
		}
	}
}

另外一种写法：

public class MyThread extends Thread{
	
	public MyThread(String name) {
		super(name);
	}

	@Override
	public void run() {
		
		//获取当前线程对象
		Thread t = Thread.currentThread();
		
		for (int i = 1; i <= 100; i++) {
			System.out.println(t.getName() + "：" + i);
		}
	}
}

String getName()：返回此线程的名称

Thread .currentThread() ：返回对当前正在执行的线程对象的引用

十一、让线程休眠

需求：编写一个抽取学员回答问题的程序，要求倒数三秒后输出被抽中的学员姓名

Thread.sleep(1000);

此方法为静态方法，写在哪个线程中，哪个线程就休眠

public class Test01 {
	public static void main(String[] args) throws InterruptedException {
		
		String[] names = {"小浩","小李","小伟","小燕","小威","小彭","小王"};
		
		Random random = new Random();
		int index = random.nextInt(names.length);
		
		for(int i = 3;i>0;i--){
			System.out.println(i);
			
			//Thread的静态方法 -- sleep(毫秒)，表示让当前线程休眠
			Thread.sleep(1000);
		}
		
		System.out.println(names[index]);// 3 2 1 小李
	}
}

static void sleep(long millis) ：使当前正在执行的线程停留（暂停执行）指定的毫秒数

简答题

1.throw 和 throws 的区别是什么？

throw 关键字用在方法内部，只能用于抛出一种异常，用来抛出方法或代码块中的异常，受检性异常和非受检性异常都可以被抛出。

throws 关键字用在方法声明上，可以抛出多个异常。一个方法用throws 标识了可能抛出的异常列表，调用该方法的方法中必须包含可处理异常的代码，否则也要在方法声明上用 throws 关键字声明相应的异常。

3.Java中的两种异常类型是什么？他们有什么区别？

Java 中有两种异常：受检性异常和非受检性异常。

非受检性异常不需要在方法或者是构造函数上声明，就算方法或者是构造函数的执行可能会抛出这样的异常，并且不受检查的异常可以传播到方法或者是构造函数的外面。相反，受检性异常必须要用 throws 语句在方法或者是构造函数上声明。

try catch finally，try里有return，finally还执行么？

执行，并且finally的执行早于try里面的return

如果try，finally语句里均有return，忽略try的return，而使用finally的return.

finally在catch的return之后执行

5.注意：异常和错误的区别：异常能被程序本身可以处理，错误是无法处理。

6.简述线程、程序、进程的基本概念。

进程是程序的一次执行过程，是系统运行程序的基本单位。系统运行一个程序即一个进程从创建，运行到消亡的过程

线程与进程相似，但线程是一个比进程更小的执行单位。一个进程在执行的过程中可以产生多个线程。同类的多个线程共享同一内存空间和系统资源。

程序是含有指令和数据的文件，被存储在磁盘或其他的数据存储设备中，也就是说程序是静态的代码。

7.线程与进程的区别？
进程是系统分配资源的最小单元，线程是系统调度的最小单元。
一个程序至少有一个进程,一个进程至少有一个线程

8.并发编程三要素？
1、原子性
原子性指的是一个或者多个操作，要么全部执行并且在执行的过程中不被其他操作打断，要么就全部都不执行。
2、可见性
可见性指多个线程操作一个共享变量时，其中一个线程对变量进行修改后，其他线程可以立即看到修改的结果。
3、有序性
有序性，即程序的执行顺序按照代码的先后顺序来执行。

总结

1.异常
异常的概念
异常的分类
异常处理
机制 – 面试题
异常处理的能力：
1.try…catch…
2.throws
3.throw

2.多线程
进程的概念
线程的概念
创建线程的方式(线程类、任务类)
线程的优先级别
给线程命名
线程的休眠

A 北枝

关注

38
点赞
踩
11

收藏

觉得还不错? 一键收藏
打赏
0
评论
学习JavaEE的日子 Day28 异常，多线程

进程是系统进行资源分配和调用的独立单元，每一个进程都有它的独立内存空间和系统资源。什么是线程？线程是进程里面的一条执行路径，每个线程同享进程里面的内存空间和系统资源一个进程可以有多个线程：各个线程都有不同的分工理解线程和进程的关系进程与进程之间的关系：进程之间的内存空间和系统资源是独立的同一个进程里的多条线程：线程之间的内存空间和系统资源是共享的进程里：可以有一条或一条以上的线程进程里只有一条线程的情况下，这条线程就叫做主线程进程里有多条线程的情况下，只有一条线程叫做主线程。
复制链接

扫一扫