【异常、线程】

最新推荐文章于 2024-08-12 15:45:48 发布
最新推荐文章于 2024-08-12 15:45:48 发布
阅读量63 收藏
点赞数
分类专栏： javase 文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46932548/article/details/106377026
版权

【异常、线程】

异常

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

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

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

异常机制其实是帮助我们找到程序中的问题，异常的根类是java.lang.Throwable,其下有两个子类：java.lang.Error与java.lang.Exception,平时所说的异常指java.lang.Exception。

extends
extends
Throwable
Error
Exception
  • **Error:**严重错误Error，无法通过处理的错误，只能事先避免。
  • Exception：编译器异常，进行编译（写代码）过程中java程序出现的异常。
    • RuntimeException：运行期异常，java程序运行过程中出现的异常。

异常产生过程的解析

对于长度为3的数组，想获取索引位置为4的元素的值时，会提示数组索引越界异常ArrayIndexOutOfBoundsException。

/*
new ArrayIndexOutOfBoundsException("3");
JVM接收到了这个异常对象，做了两件事情：
    1.把异常对象（内容，原因，位置）以红色的字体打印在控制台
    2.JVM会终止当前正在执行的java程序-->中断处理。
 */
public class Demo01Exception {
    public static void main(String[] args) {
        //创建int类型的数组，并赋值
        int[] arr = new int[]{1,2,3};
        int e = getElement(arr,3);
        /*
        new ArrayIndexOutOfBoundsException("3");
        main方法接收到了这个异常对象，main方法也没有异常的处理逻辑，
        继续把对象抛出给main方法的调用者JVM处理
         */
        System.out.println(e);
        
    }
    public static int getElement(int[] arr,int index){
        /*
        访问了数组中的3索引，而数组是没有3索引的，这时候JVM就会检测出程序会出现异常
        JVM会做两件事情：
            1.JVM会根据异常产生的原因创建一个异常对象，这个异常对象包含了异常产生的（内容，原因，位置）
                new ArrayIndexOutOfBoundsException("3");
            2.在getElement方法中，没有异常的处理逻辑，那么JVM就会把异常对象抛出给方法的调用者，
              也就是main方法处理这个对象。
         */
        int ele = arr[index];
        return ele;
    }
}

异常的处理

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

throw关键字—抛出异常

作用：

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

使用格式：

  • throw new xxxException(“异常产生的原因”)；

注意：

  1. throw关键字必须写在方法的内部；

  2. throw关键字后面new的对象必须是Exception或者是Exception的子类对象

  3. throw关键字抛出指定的异常对象，我们就必须处理这个异常对象

    • 如果throw关键字后面创建的是RuntimeException或者是RuntimeException的子类对象

      我们可以不处理，默认交给JVM处理（打印异常对象，中断程序）

    • 如果throw关键字后边创建的是编译异常（写代码时候报错）

      我们就必须处理这个异常，要么throws，要么try…catch…

public class Demo01Throw {
    public static void main(String[] args) {
        int[] arr = null;
        getElement(arr,1);
        //Exception in thread "main" java.lang.NullPointerException: 传递的数组的值是null
        int[] arr1 = {1,2,3};
        getElement(arr1,3);
        //Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 传递的索引超过数组的索引范围


    }
    public static int getElement(int[] arr,int index){
        /*
        我们可以对传递过来的参数数组，进行合法性校验
        如果数组arr的值时null
        那么我们就抛出空指针异常，告知方法的调用者“传递的数组的值是null”
         */
        if(arr==null){
            throw new NullPointerException("传递的数组的值是null");
        }
        /*
        我们可以对传递过来的参数index进行合法性校验
        如果index的范围不在数组的索引范围内
        那么我们就抛出数组索引越界异常，告知方法的调用者“传递的索引超出了数组的适用范围”
         */
        if (index > arr.length-1 || index < 0 ){
            throw new ArrayIndexOutOfBoundsException("传递的索引超过数组的索引范围");
        }
        int element = arr[index];
        return element;
    }
}
Objects非空判断_requireNonNull方法

Objects类中的静态方法：

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

源码：

`public static T requireNonNull(T obj){

​ if(obj == null){

​ throw new NullPointerException();

​ }

​ return obj;

}

import java.util.Objects;

public class Demo01Objects {
    public static void main(String[] args) {
        int[] arr = null;
        method(arr);
    }
    public static void method(Object obj){
        //对传递过来的参数进行合法性判断，判断是否为null
//        if (obj == null){
//            throw new NullPointerException("传递的对象的值是null");
//
//        }
//        Objects.requireNonNull(obj);
        Objects.requireNonNull(obj,"传递的对象的值是null");
    }
}

throws关键字

异常处理的第一种方式，交给别人处理。

作用：

  • 当方法内部抛出异常对象的时候，那么我们就必须处理这个异常对象

    可以使用throws关键字处理异常对象，会把异常对象声明抛出给方法的调用者处理

    （自己不处理，交给别人处理，最终交给JVM处理）

    最终交给JVM处理 --> 中断处理

使用格式（在方法声明时使用）：

修饰符 返回值类型 方法名（参数列表） throws AAAException,BBBException… {

​ throw new AAAException(“产生原因”)；

​ throw new BBBException(“产生原因”)；

​ …

}

注意：

  1. throws关键字必须写在方法声明处；
  2. throws关键字后面声明的异常必须是Exception或者是Exception的子类
  3. 方法内部如果抛出了多个异常对象，那么throws后面必须也声明多个异常
    • 如果抛出多个异常对象有字符类关系，那么直接声明父类异常即可
  4. 调用了一个声明抛出异常的方法，我们就必须得处理声明的异常
    • 要么继续使用throws声明抛出，交给方法的调用者处理，最终交给JVM处理
    • 要么try…catch自己处理异常
/*
    定义一个方法，对传递的文件路径进行合法性判断
    如果路径不是“c:\\a.txt”，那我我们就抛出文件找不到异常对象，告知方法的调用者
    注意：
        FileNotFoundException是编译异常，抛出了编译异常，就必须处理这个异常
        1.可以使用throws，继续声明抛出FileNotFoundException这个异常对象，交给方法的调用者处理
	   2.可以使用try...catch方法
 */

可以使用throws:

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

public class Demo01Throws {
    public static void main(String[] args) throws FileNotFoundException, IOException {
        readFile("c:\\\\a.txt");
        //路径没有问题，读取文件
        readFile("d:\\\\a.txt");
        //Exception in thread "main" java.io.FileNotFoundException: 传递的文件路径不是c:\\a.txt
        readFile("c:\\\\a.doc");
        //Exception in thread "main" java.io.IOException: 文件的后缀名不对
    }


    public static void readFile(String filename) throws FileNotFoundException, IOException {
        //如果传递的路径，不是.txt结尾
        //那么我们就抛出IO异常对象，告知方法的调用者，文件的后缀名不对
        if (!filename.endsWith(".txt")) {
            throw new IOException("文件的后缀名不对");
        }
        //如果文件名不对
        // 那么我们就抛出FileNotFoundException异常对象，告知方法的调用者，文件的后缀名不对
        if (!filename.equals("c:\\\\a.txt")) {
            throw new FileNotFoundException("传递的文件路径不是c:\\\\a.txt");
        }
        System.out.println("路径没有问题，读取文件");
    }

}

try_catch

try…catch：异常处理的第二种方式，自己处理异常

格式：

try{

​ 可能产生异常的代码

}catch(定义一个异常的变量，用来接收try中抛出的异常对象){

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

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

}

catch可以有多种：

catch(异常类名 变量名){

}

注意：

  1. try中可能会抛出多个异常对象，那么就可以使用多个catch来处理这些异常对象
  2. 如果try中产生了异常，那么就会执行catch中的异常处理逻辑，执行完毕catch中的处理逻辑，继续执行try…catch之后的代码
  3. 如果try中没有产生异常，那么就不会执行catch中的异常的处理逻辑，执行完try中的代码，继续执行try…catch之后的代码
import java.io.FileNotFoundException;
import java.io.IOException;

public class Demo01TryCatch {
    public static void main(String[] args) {
        try {
            readFile("d:\\\\a.txt");
        } catch (IOException e) {
            //try中抛出什么异常对象，catch中就定义什么异常变量，用来接收这个异常对象
            //异常的处理逻辑，产生异常对象之后，怎么处理异常对象
            System.out.println("catch - 传递的文件后缀名不是c:\\\\a.txt");

        }
        System.out.println("后面的代码可继续执行！");

    }

    public static void readFile(String filename) throws IOException {
        //如果传递的路径，不是.txt结尾
        //那么我们就抛出IO异常对象，告知方法的调用者，文件的后缀名不对
        if (!filename.endsWith(".txt")) {
            throw new IOException("文件的后缀名不对");
        }
        //如果文件名不对
        // 那么我们就抛出FileNotFoundException异常对象，告知方法的调用者，文件的后缀名不对
        if (!filename.equals("c:\\\\a.txt")) {
            throw new FileNotFoundException("传递的文件路径不是c:\\\\a.txt");
        }
        System.out.println("路径没有问题，读取文件");
    }
}

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

Throwable类中定义了三个异常处理的方法：

方法含义
String getMessage();返回此throwable的简短描述
String toString();返回此throwable的详细消息字符串
void printStackTrace();JVM打印异常对象，默认此方法，打印的异常信息是最全面的
try {
            readFile("d:\\\\a.txt");
        } catch (IOException e) {
            //try中抛出什么异常对象，catch中就定义什么异常变量，用来接收这个异常对象
            //异常的处理逻辑，产生异常对象之后，怎么处理异常对象
            System.out.println(e.getMessage());
            System.out.println(e.toString());
            e.printStackTrace();

        }

finally代码块

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

格式：

try{

​ 可能产生异常的代码

}catch(定义一个异常的变量，用来接收try中抛出的异常对象){

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

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

}finally{

​ 无论是否出现异常都会执行

}

注意：

  1. finally不能单独使用，必须和try一起使用；
  2. finally一般用于资源释放（资源回收），无论程序是否出现异常，最后都要资源释放（IO）。
 try {
            //可能会产生异常的代码
            readFile("d:\\\\a.txt");
        } catch (IOException e) {
            //异常的处理逻辑，产生异常对象之后，怎么处理异常对象
            System.out.println(e.getMessage());
            System.out.println(e.toString());
            e.printStackTrace();

        } finally {
            //无论是否出现异常，都会执行
            System.out.println("资源释放");
        }

异常的注意事项

多异常的捕获处理

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

  1. 多个异常分别处理；
  2. 多个异常一次捕获，分别处理；
    • 注意事项：catch里面定义的异常变量，如果有子父类关系，那么子类的异常变量必须写在前面，否则就会报错。
  3. 多个异常一次捕获一次处理。
public class Demo02ExceptionCautions {
    public static void main(String[] args) {
        //第一种，分别捕获分别处理
        try {
            int[] arr = {1, 2, 3};
            System.out.println(arr[3]);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println(e);
            //java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
        }
        try {
            List<Integer> list = null;
            System.out.println(list.get(3));
        } catch (NullPointerException e) {
            System.out.println(e);
            //java.lang.NullPointerException
        }
        System.out.println("后续代码");


    }
}
public class Demo02ExceptionCautions {
    public static void main(String[] args) {
        //第二种，一次捕获分别处理
        try {
            int[] arr = {1, 2, 3};
            //System.out.println(arr[3]);
            List<Integer> list = null;
            System.out.println(list.get(3));
        } catch (NullPointerException e) {
            System.out.println(e);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println(e);
            //java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
        }

    }
}
public class Demo02ExceptionCautions {
    public static void main(String[] args) {
        //第三种，一次捕获一次处理
        try {
            int[] arr = {1, 2, 3};
            System.out.println(arr[3]);
            List<Integer> list = null;
            System.out.println(list.get(3));
        } catch (Exception e) {
            System.out.println(e);
        }

    }
}

finally有return语句

如果finally中有return语句，永远返回finally中的结果，要避免该情况。

public class Demo02FinallyCautions {
    public static void main(String[] args) {
        System.out.println(getA());
        //永远返回finally代码块中的结果，避免该情况
    }

    public static int getA() {
        int a = 10;
        try {
            return a;
        } catch (Exception e) {
            System.out.println(e);
        } finally {
            //一定会执行的代码
            a = 20;
            return a;
        }
    }
}

子父类异常

  1. 如果父类抛出了多个异常，子类重写父类方法时，抛出和父类相同的异常或者父类异常的子类或者不抛出异常；
  2. 父类方法没有抛出异常，子类重写父类该方法时也不能抛出异常，此时子类产生该异常，只能捕获处理，不能声明抛出。
public class Fu {
    public void show01() throws  NullPointerException,ClassCastException{}
    public void show02() throws IndexOutOfBoundsException{}
    public void show03() throws Exception{}
    public void show04(){}
}
class Zi extends Fu{
    //子类重写父类方法时，抛出和父类相同的异常
    @Override
    public void show01() throws  NullPointerException,ClassCastException{}
    //子类重写父类方法时，抛出和父类异常的子类
    @Override
    public void show02() throws ArrayIndexOutOfBoundsException{}
    //子类重写父类方法时，不声明异常
    @Override
    public void show03() {}
    //父类方法没有抛出异常时，子类重写方法如有异常只能捕获处理，不能声明抛出
    @Override
    public void show04(){
        try{
            int[] arr = null;
            System.out.println(arr[0]);
        }catch (NullPointerException e){
            System.out.println(e);
        }
    }
    
}

自定义异常

API提供的异常类不能完全满足日常使用，需要自定义异常类。

例如，定义注册异常：RegisterException。

格式：

public class XxxException extends Exception | RuntimeException{

​ 添加一个空参构造方法

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

}

注意：

  1. 自定义异常类一般都是Exception结尾，说明该类是一个异常类
  2. 自定义异常类，必须继承Exception类或者是RuntimeException类
    • 继承Exception：那么自定义的异常类就是一个编译器异常，如果方法内部抛出了编译器异常，就必须处 理这个异常，要么throws，要么try…catch
    • 继承RuntimeException：那么自定义的异常类就是一个运行期异常，无需处理，交给JVM处理（中断处理）
public class RegisterException extends Exception {
    public RegisterException(){
//        super();
    }
    /*
    添加一个带异常信息的构造方法
    查看源码发现，所有的异常类都会有一个带异常信息的构造方法，
    方法的内部会调用父类带异常信息的构造方法，让父类来处理这个异常信息
     */
    public RegisterException(String info){
        super(info);
    }
}

练习

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

第一种，声明处理：

import java.util.Scanner;

public class Exercise {
    //1.使用数组保存已经注册过的用户名（数据库）
    static String[] userNames = {"James","Kobe","Iverson"};
    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 userNameExist : userNames) {
            if (userNameExist.equals(userName)){
                throw new RegisterException("亲，该用户名已经被注册");
            }

        }
        System.out.println("恭喜您，注册成功！");
    }
}

第二种，捕获处理；

import java.util.Scanner;

public class Exercise {
    //1.使用数组保存已经注册过的用户名（数据库）
    static String[] userNames = {"James","Kobe","Iverson"};
    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){
        for (String userNameExist : userNames) {
            if (userNameExist.equals(userName)){
                try{
                    throw new RegisterException("亲，该用户名已经被注册");
                }catch (RegisterException e){
                    System.out.println(e);
                    return;
                }
            }

        }
        System.out.println("恭喜您，注册成功！");
    }
}

并发与并行

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

并行：指两个或多个事件在同一时刻发生（同时发生）；

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dghwfdWN-1590548888986)(C:\Users\Ann\Desktop\java学习文档\笔记\picture\并发与并行.png)]

进程与线程

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

  • **线程：**线程是进程中的一个执行单位，负责当前进程中程序的运行，一个进程至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

    • 点击程序（进程）的一个功能，就会开启一条应用程序到CPU的执行路径，CPU就可以通过这个路径执行功能，这个路径的就是线程。

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

对于单核心单线程CPU，CPU在多个线程之间做高速的切换，轮流执行多个线程，虽然切换的速度非常快，但是终归效率是低下的；

对于4核心8线程CPU，可以同时执行8个线程，8个线程在多个任务之间做高速切换，运行速度是单线程的8倍。

线程调度

  • 分时调度：
    • 所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间。
  • 抢占式调度：
    • 优先让优先级高的线程使用CPU，如果线程的优先级相同，就会随机选择一个线程（线程随机性），Java使用的为抢占式调度。

主线程

主线程：执行主线程（main线程）方法的线程。

单线程程序：Java程序中只有一个线程；执行从main方法开始，从上往下依次执行。

JVM执行main方法，main方法会进入到栈内存。

JVM会找操作系统开辟一条main方法通向cpu的执行路径，cpu就可以通过这条路径来执行main方法。

而这个路径就是main线程（主线程）。

**线程：**线程是进程中的一个执行单位，负责当前进程中程序的运行，一个进程至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

  • 点击程序（进程）的一个功能，就会开启一条应用程序到CPU的执行路径，CPU就可以通过这个路径执行功能，这个路径的就是线程。

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

对于单核心单线程CPU，CPU在多个线程之间做高速的切换，轮流执行多个线程，虽然切换的速度非常快，但是终归效率是低下的；

对于4核心8线程CPU，可以同时执行8个线程，8个线程在多个任务之间做高速切换，运行速度是单线程的8倍。

线程调度

  • 分时调度：
    • 所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间。
  • 抢占式调度：
    • 优先让优先级高的线程使用CPU，如果线程的优先级相同，就会随机选择一个线程（线程随机性），Java使用的为抢占式调度。

主线程

主线程：执行主线程（main线程）方法的线程。

单线程程序：Java程序中只有一个线程；执行从main方法开始，从上往下依次执行。

JVM执行main方法，main方法会进入到栈内存。

JVM会找操作系统开辟一条main方法通向cpu的执行路径，cpu就可以通过这条路径来执行main方法。

而这个路径就是main线程（主线程）。

五岁能抬头1995
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用 Process Explorer 和 Windbg 排查软件线程堵塞问题
dvlinker的技术专栏
01-09 1万+
本文详细介绍如何使用 Process Explorer 和 Windbg 排查软件线程堵塞问题。
排除异常线程
墨染锦年的博客
03-30 3324
通过top、ps命令查看实时线程，未发现异常 slabinfo内存管理器 （1）slabtop命令，查看无异常； （2）查看slabinfo信息（cat /proc/slabinfo） slab是Linux内核中按照对象大小进行分配的内存分配器，通过slabinfo可以观察到系统中内存分配情况。 ——size-128一直在增加，说明128字节的内存大小空间存在使用后未释放。 ...
线程异常处理
LZN的博客
05-06 1554
文章目录一、线程池异常处理流程二、源码执行流程2.1 execute 执行流程2.2 submit 执行流程三、线程异常捕获方法3.1 在 Runnable#run 方法中捕获代码异常3.2 在 Callable#call 方法中捕获异常3.3 重写 ThreadPoolExecutor#afterExecute3.4 为工作者线程设置 UncaughtExceptionHandler 一、线程池异常处理流程 1.1 当执行方式是 execute 时，可以看到堆栈异常的输出 原因：ThreadPoolExe
线程中出现异常的处理
m0_62943934的博客
12-04 1585
在紧密交织的多线程环境中，异常处理是一个经常被讨论的容易被忽视的关键部分。这并不奇怪，因为在编写并发代码时，管理和理解可能出现的各种异常条件可能是一个挑战。在单线程环境中，发生异常时，异常信息会立刻被捕获并处理，然而，在多线程环境中的异常处理复杂性要高很多。未被正确处理的异常可能导致全局性影响，甚至系统崩溃。这给程序稳定性带来威胁，且可能会导致无法预料的行为。因此，对于编写健壮且可靠的并发代码来说，理解并且正确处理线程中的异常是至关重要的。本文旨在深入探讨Java中线程级别的异常处理。
java线程异常终止_Java线程异常结束怎么解决
weixin_34220502的博客
02-12 2221
Java中线程异常结束的解决方法是：首先捕获线程执行过程中所产生的异常；然后当线程异常时，会通过调用setUncaughtExceptionHandler方法来捕获异常；最后再解决即可。【推荐教程：Java教程】我们开发工程中经常使用到线程，在线程使用上，我们可能会有这样的场景：(1)伴随这一个业务产生一个比较耗时的任务，而这个业务返回并不需要等待该任务。那我们往往会启动一个线程去完成这个异步任务...
setUncaughtExceptionHandler捕获异常线程
enthan809882的博客
02-06 2451
线程中的异常有点特殊。直接加try catch是捕获不到的。因为try catch的当前线程是main线程。 异常实在线程里面发生的，不属于main线程。 直接用try catch捕获不到异常： public class ThreadExceptionDemo implements Runnable{ @Override public void run() { Sy...
java线程异常_java线程异常处理方法
weixin_42360733的博客
02-20 1737
工作中常发现有些程序发生异常但却没有错误日志，原因就是一些开发线程异常处理错误，导致程序报错但异常信息打印到堆栈上，不好在生产环境中定位问题。在java多线程程序中，所有线程都不允许抛出未捕获的checked exception(比如sleep时的InterruptedException)，也就是说各个线程需要自己把自己的checked exception处理掉。这一点是通过java.lang.R...
如何获取线程池中的异常
m0_57713282的博客
03-10 3178
1.若不需要处理返回值，则可以使用execute()方法来提交任务，当任务发生异常时，线程会抛出异常，同时我们也可以在run方法中捕获处理异常 2.若需要返回值，需要使用submit()方法时 （1）直接在run方法中捕获异常，包括未受检异常 （2）利用Future对象的get()方法，对该方法捕获异常，因为线程中出现的异常会抛给get()方法，简单来说，就是线程中出现了异常，就相当于get()方法出现了异常 （3）重写ThreadpoolExecutor的executor.afterExecute
线程异常重启
java小强的博客
08-16 3493
线程的异常处理不能像普通程序一样出现异常后抛出然后由创建并启用该线程的主线程try catch后进行异常处理，而是只能由该子线程自己try catch自己的异常，比如该子线程中连接数据库或者操作文件，会有可能出现IOException或者SQLException等异常，而且这些异常一旦发生，线程就会中止，中止的线程并不会对其他线程或者主线程造成影响，不过有时当我们用子线程去连接数据库时，假如连接不
线程池内运行的线程抛异常，线程池会怎么办
击水三千里的专栏
08-16 5534
当线程池中线程执行任务的时候，任务出现未被捕获的异常的情况下，线程池会将允许该任务的线程从池中移除并销毁，且同时会创建一个新的线程加入到线程池中；可以通过ThreadFactory自定义线程并捕获线程内抛出的异常，也就是说甭管我们是否去捕获和处理线程池中工作线程抛出的异常，这个线程都会从线程池中被移除。
JavaSE异常与多线程
06-04
入门级笔记，适合查漏补缺。
delphi线程异常处理
06-16
然而，如同任何其他编程环境一样，线程在执行过程中可能会遇到异常（Exception），这些异常如果不妥善处理，可能导致程序崩溃或数据丢失。因此，理解并正确实现Delphi线程中的异常处理机制至关重要。 首先，让我们...
线程监控工具，查找异常线程
03-13
本文将深入探讨线程监控工具的功能、用途，以及如何利用这些工具查找并解决异常线程问题。 线程监控工具主要功能： 1. **线程查看**：这类工具能够列出运行中的所有线程，包括线程ID、状态（如运行、等待、阻塞等）...
day07【异常、线程】.md
05-31
异常、线程学习笔记
Java多线程之多线程异常捕捉
09-03
在Java多线程编程中，异常处理是一项关键的机制，特别是在多线程环境下，由于线程的并发执行，处理异常的方式与单线程有所不同。本文将深入探讨Java多线程中的异常捕捉，以及如何有效地在多线程环境中处理异常。 ...
Java面试篇（JVM相关专题）
聂可以的博客
08-09 2747
Java面试篇（JVM相关专题）
SpringBoot快速入门（手动创建）
m0_74124657的博客
08-11 321
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
springboot民办高校科研项目管理系统-计算机毕业设计源码54009
VX_DZbishe的博客
08-11 466
论文主要是对基于springboot的民办高校科研项目管理系统进行了介绍，包括研究的现状，还有涉及的开发背景，然后还对系统的设计目标进行了论述，还有系统的需求以及整个的设计方案，对系统的设计以及实现，也都论述的比较细致，最后对基于springboot的民办高校科研项目管理系统进行了一些具体测试。本次报告，首先分析了研究的背景、作用、意义，为研究工作的合理性打下了基础。
集合（1）
最新发布
supercool7的博客
08-12 461
表示不同的类型集合，Collection、Map、List、Set、Queue、Deque等，以及辅助性质的接口Iterator、LinkIterator、Comparator、Comparable这些接口是为迭代和比较元素而准备。对接口的具体实现，主要常用的有：ArrayList、LinkedList、HashMap、HashSet、TreeMap等等。理解Java集合体系可以从三个层次：最上层的接口、中间的抽象类、最后的实现类。是所有集合框架的根接口，包含了对集合进行基本操作的方法。
countdownlatch.await异常线程阻塞
09-01
这可能是因为以下几种情况之一导致的异常线程阻塞： 1. 计数器没有被正确地减至零：请确保所有需要等待的线程都已经调用了`countDown()`方法，以便将计数器减至零。 2. 计数器为零时，仍然有线程调用了`await()`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值