第八章异常（是程序在执行过程中，出现的非正常的情况，如果不处理最终会导致JVM的非正常停止）

慕青盼烟2024-05-06 21:59

目录

2、如何对待异常

3、异常的抛出机制

[8.1.2 Java异常体系](#8.1.2 Java异常体系)

1、Throwable

2、Error和Exception

[8.1.3 受检异常和非受检异常](#8.1.3 受检异常和非受检异常)

演示常见的错误和异常

1、Error

2、运行时异常

3、编译时异常

[8.2 异常的处理](#8.2 异常的处理)

[8.2.1 捕获异常：try...catch](#8.2.1 捕获异常：try…catch)

1、try...catch基本格式

2、JDK1.7try...catch新特性

3、在catch分支中获取异常信息

[8.2.2 finally块](#8.2.2 finally块)

1、finally块

2、finally与return

转换异常处理位置：throws

1、throws编译时异常

2、throws运行时异常

3、方法重写对于throws要求

手工抛出异常对象：throw

自定义异常

在使用计算机语言进行项目开发的过程中，即使程序员把代码写得尽善尽美，在系统的运行过程中仍然会遇到一些问题，因为很多问题不是靠代码能够避免的，比如：客户输入数据的格式问题，读取文件是否存在，网络是否始终保持通畅等等。

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

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

异常也不是指逻辑代码错误而没有得到想要的结果，例如：求a与b的和，你写成了a-b

java 复制代码 
package com.day428.Demo01;
/*
*异常指的并不是语法错误,语法错了,编译不通过,不会产生字节码文件,根本不能运行.

异常也不是指逻辑代码错误而没有得到想要的结果，例如：求a与b的和，你写成了a-b
*
* */
public class Demo0001 {
    public static void main(String[] args) {
//        语法错误，编译错误，根本无法运行。
//        System.out.println(a);
//        System.out.println(add(1,2));
//        System.out.println(add("11","23"));
    }
    public static int add(int a, int b){
        return a-b;
    }
}
java 复制代码 
package com.day428.Demo01;

import java.util.Scanner;
/*
* 避免异常
* 解决异常
*尽量提高代码的可用性，增加判断处理，保证不会输入异常，
* 超出数组下标，类型转换不出现这样的异常
* 2.加异常代码L:try{
* }catch(Exception e){
*
* }
* nextLine(),可以识别除换行外，其它任何字符
*
* */
public class Demo0002 {
    public static void main(String[] args) {
                Scanner scanner = new Scanner(System.in);
        while (true){
            try{
                System.out.println("请你输入一个数");
                int num= scanner.nextInt();
                int num2 =scanner.nextInt();
                System.out.println(add1(num,num2));
                break;
            }catch (Exception e){
                scanner.nextLine();
                System.out.println("请输入整数");

            }
        }

    }
    public static int add1(int a,int b){
        return a-b;
    }
}
2、如何对待异常

程序员在编写程序时，就应该充分考虑到各种可能发生的异常和错误，极力预防和避免，实在无法避免的，要编写相应的代码进行异常的检测、异常消息的提示，以及异常的处理。

3、异常的抛出机制

Java中是如何表示不同的异常情况，又是如何==让程序员得知==，并==处理异常==的呢？

Java中把不同的异常用不同的类表示，一旦发生某种异常，就通过创建该异常类型的对象，并且抛出，然后程序员可以catch到这个异常对象，并处理，如果无法catch到这个异常对象，那么这个异常对象将会导致程序终止。

运行下面的程序，程序会产生一个数组索引越界异常ArrayIndexOfBoundsException。我们通过图解来解析下异常产生和抛出的过程。

java 复制代码 
package com.day428.Demo01;
/*
*
* ArrayIndexOutOfBoundsException
* 异常抛出机制
*
* */
public class ArrayTools {
    public static void main(String[] args) {
        int[] arr ={1,2,3,4,5};
//        1.getElement方法中获取到一个非正常的返回值，而是得到一个异常对象。
//        try，...catch捕获
//        如果没有,就到mian中抛出异常,程序中断。
        ArrayTools.getElement(arr,23);

    }
    public static int getElement(int arr[] ,int index){
//
        int ele =arr[index];
//        程序报错后就停止，创建一个对应的异常类型的对象。
//        JVM 会被i这个异常对象抛出。
//       先检测有没有try..catch语句，如果有try...catch语句
//        就是使用try...catch语句中的catch语句捕获这个异常对象，，如果没有，则抛出给调用者。
        System.out.println("程序停止了");
        return ele;
    }
}

8.1.2 Java异常体系

1、Throwable

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

  • 只有当对象是此类（或其子类之一）的实例时，才能通过 Java 虚拟机或者 Java 的throw 语句抛出。类似地，只有此类或其子类之一才可以是 catch 子句中的参数类型。

Throwable中的常用方法：

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

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

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

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

2、Error和Exception

Throwable有两个直接子类：java.lang.Error与java.lang.Exception，平常所说的异常指java.lang.Exception。

  • Error：表示严重错误，一旦发生必须停下来查看问题并解决问题才能继续，无法仅仅通过try...catch解决的错误。（如果拿生病做比喻，就像是突发疾病，而且是危重症，必须立刻停下来治疗而不是靠短暂休息、吃药、打针、或小手术简单解决处理）

    • 例如：StackOverflowError（栈内存溢出）和OutOfMemoryError（堆内存溢出，简称OOM）。

  • Exception：表示普通异常，其它因编程错误或偶然的外在因素导致的一般性问题，程序员可以通过代码的方式检测、提示和纠正，使程序继续运行，但是只要发生也是必须处理，否则程序也会挂掉。（这就好比普通感冒、阑尾炎、牙疼等，可以通过短暂休息、吃药、打针、或小手术简单解决，但是也不能搁置不处理，不然也会要人命）。

    • 例如：空指针访问、试图读取不存在的文件、网络连接中断、数组下标越界等

无论是Error还是Exception，还有很多子类，异常的类型非常丰富。当代码运行出现异常时，特别是我们不熟悉的异常时，不要紧张，把异常的简单类名，拷贝到API中去查去认识它即可。

8.1.3 受检异常和非受检异常

我们平常说的异常就是指Exception，根据代码的编写编译阶段，编译器是否会警示 当前代码可能发生xx异常，并督促程序员提前编写处理它的代码为依据，可以将异常分为：

  • 编译时期异常 （即checked异常、受检异常）：在代码编译阶段，编译器就能明确警示 当前代码可能发生（不是一定发生） xx异常，并督促 程序员提前编写处理它的代码。如果程序员不听话 ，没有编写对应的异常处理代码，则编译器就会发威，直接判定编译失败，从而程序无法执行。通常，这类异常的发生不是由程序员的代码引起的，或者不是靠加简单判断就可以避免的，例如：FileNotFoundException（文件找不到异常）。

  • 运行时期异常（即runtime异常、unchecked非受检异常）：即在代码编译阶段，编译器完全不做任何检查，无论该异常是否会发生，编译器都不给出任何提示。只有等代码运行起来并确实发生了xx异常，它才能被发现。通常，这类异常是由程序员的代码编写不当引起的，只要稍加判断，或者细心检查就可以避免的。例如：ArrayIndexOutOfBoundsException数组下标越界异常，ClassCastException类型转换异常。

演示常见的错误和异常

1、Error

最常见的就是VirtualMachineError，它有两个经典的子类：StackOverflowError、OutOfMemoryError。

public class TestStackOverflowError {

public void test01(){

//StackOverflowError

digui();

}

public void digui(){

digui();

}

}

public class TestOutOfMemoryError {

public void test02(){

//OutOfMemoryError

//方式一：

int[] arr = new int[Integer.MAX_VALUE];

}

public void test03(){

//OutOfMemoryError

//方式二：

StringBuilder s = new StringBuilder();

while(true){

s.append("haogu");

}

}

}

2、运行时异常
java 复制代码 
public class TestRuntimeException {
    public void test01(){
        //NullPointerException
        int[][] arr = new int[3][];
        System.out.println(arr[0].length);
    }

    public void test02(){
        //ClassCastException
        Object obj = 15;
        String str = (String) obj;
    }

    public void test03(){
        //ArrayIndexOutOfBoundsException
        int[] arr = new int[5];
        for (int i = 1; i <= 5; i++) {
            System.out.println(arr[i]);
        }
    }

    public void test04(){
        //InputMismatchException
        Scanner input = new Scanner(System.in);
        System.out.print("请输入一个整数：");//输入非整数
        int num = input.nextInt();
        input.close();
    }
    public void test05(){
        int a = 1;
        int b = 0;
        //ArithmeticException
        System.out.println(a/b);
    }
}
3、编译时异常
java 复制代码 
import org.junit.Test;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class TestCheckedException {
    public void test06() throws InterruptedException{
        Thread.sleep(1000);//休眠1秒
    }

    public void test07() throws FileNotFoundException {
        FileInputStream fis = new FileInputStream("Java从入门到精通.txt");
    }

    public void test08() throws SQLException {
        Connection conn = DriverManager.getConnection("....");
    }
}

8.2 异常的处理

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

8.2.1 捕获异常：try...catch

1、try...catch基本格式

捕获异常语法如下：

try{

可能发生xx异常的代码

}catch(异常类型1 e){

处理异常的代码1

}catch(异常类型2 e){

处理异常的代码2

}

....

try{}中编写可能发生xx异常的业务逻辑代码。

catch分支，分为两个部分，catch()中编写异常类型和异常参数名，{}中编写如果发生了这个异常，要做什么处理的代码。如果有多个catch分支，并且多个异常类型有父子类关系，必须保证小的子异常类型在上，大的父异常类型在下。

当某段代码可能发生异常，不管这个异常是编译时异常（受检异常）还是运行时异常（非受检异常），我们都可以使用try块将它括起来，并在try块下面编写catch分支尝试捕获对应的异常对象。

  • 如果在程序运行时，try块中的代码没有发生异常，那么catch所有的分支都不执行。

  • 如果在程序运行时，try块中的代码发生了异常，根据异常对象的类型，将从上到下选择第一个匹配的catch分支执行。此时try中发生异常的语句下面的代码将不执行，而整个try...catch之后的代码可以继续运行。

  • 如果在程序运行时，try块中的代码发生了异常，但是所有catch分支都无法匹配（捕获）这个异常，那么JVM将会终止当前方法的执行，并把异常对象"抛"给调用者。如果调用者不处理，程序就挂了。

java 复制代码 
public class TestTryCatch {
    public static void main(String[] args) {
        try {
            int a = Integer.parseInt(args[0]);
            int b = Integer.parseInt(args[1]);
            int result = a/b;
            System.out.println("result = " + result);
        } catch (NumberFormatException e) {
            System.out.println("数字格式不正确，请输入两个整数");
        } catch (ArrayIndexOutOfBoundsException e){
            System.out.println("数字个数不正确，请输入两个整数");
        } catch (ArithmeticException e){
            System.out.println("第二个整数不能为0");
        }

        System.out.println("你输入了" + args.length +"个参数。");
        System.out.println("你输入的被除数和除数分别是：");
        for (int i = 0; i < args.length; i++) {
            System.out.print(args[i]+"  ");
        }
        System.out.println();
    }
}
2、JDK1.7try...catch新特性

如果多个catch分支的异常处理代码一致，那么在JDK1.7之后还支持如下写法：

try{

可能发生xx异常的代码

}catch(异常类型1 | 异常类型2 e){

处理异常的代码1

}catch(异常类型3 e){

处理异常的代码2

}

....

java 复制代码 
public class TestJDK7 {
    public static void main(String[] args) {
        try {
            int a = Integer.parseInt(args[0]);
            int b = Integer.parseInt(args[1]);
            int result = a/b;
            System.out.println("result = " + result);
        } catch (NumberFormatException | ArrayIndexOutOfBoundsException e) {
            System.out.println("数字格式不正确，请输入两个整数");
        }catch (ArithmeticException e){
            System.out.println("第二个整数不能为0");
        }

        System.out.println("你输入了" + args.length +"个参数。");
        System.out.println("你输入的被除数和除数分别是：");
        for (int i = 0; i < args.length; i++) {
            System.out.print(args[i]+"  ");
        }
        System.out.println();
    }
}
3、在catch分支中获取异常信息

如何获取异常信息，Throwable类中定义了一些查看方法:

  • public String getMessage():获取异常的描述信息,原因(提示给用户的时候,就提示错误原因。
  • public void printStackTrace():打印异常的跟踪栈信息并输出到控制台。

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

8.2.2 finally块

1、finally块

因为异常会引发程序跳转，从而会导致有些语句执行不到。而程序中有一些特定的代码无论异常是否发生，都需要执行。例如，IO流的关闭，数据库连接的断开等。这样的代码通常就会放到finally块中。

java 复制代码 
try{
     
 }catch(...){
     
 }finally{
     无论try中是否发生异常，也无论catch是否捕获异常，也不管try和catch中是否有return语句，都一定会执行
 }
 
 或
  try{
     
 }finally{
     无论try中是否发生异常，也不管try中是否有return语句，都一定会执行。
 }

注意:finally不能单独使用。

当只有在try或者catch中调用退出JVM的相关方法，例如System.exit(0),此时finally才不会执行,否则finally永远会执行。

java 复制代码 
import java.util.InputMismatchException;
import java.util.Scanner;

public class TestFinally {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        try {
            System.out.print("请输入第一个整数：");
            int a = input.nextInt();
            System.out.print("请输入第二个整数：");
            int b = input.nextInt();
            int result = a/b;
            System.out.println(a + "/" + b +"=" + result);
        } catch (InputMismatchException e) {
            System.out.println("数字格式不正确，请输入两个整数");
        }catch (ArithmeticException e){
            System.out.println("第二个整数不能为0");
        } finally {
            System.out.println("程序结束，释放资源");
            input.close();
        }
    }
}
2、finally与return

finally中写了return语句，那么try和catch中的return语句就失效了，最终返回的是finally块中的

形式一：从try回来

java 复制代码 
public class TestReturn {
	public static void main(String[] args) {
		int result = test("12");
		System.out.println(result);
	}

	public static int test(String str){
		try{
			Integer.parseInt(str);
			return 1;
		}catch(NumberFormatException e){
			return -1;
		}finally{
			System.out.println("test结束");
		}
	}
}

形式二：从catch回来

java 复制代码 
public class TestReturn {
	public static void main(String[] args) {
		int result = test("a");
		System.out.println(result);
	}

	public static int test(String str){
		try{
			Integer.parseInt(str);
			return 1;
		}catch(NumberFormatException e){
			return -1;
		}finally{
			System.out.println("test结束");
		}
	}
}

形式三：从finally回来

java 复制代码 
public class TestReturn {
	public static void main(String[] args) {
		int result = test("a");
		System.out.println(result);
	}

	public static int test(String str){
		try{
			Integer.parseInt(str);
			return 1;
		}catch(NumberFormatException e){
			return -1;
		}finally{
            System.out.println("test结束");
			return 0;
		}
	}
}

转换异常处理位置：throws

1、throws编译时异常

如果在编写方法体的代码时，某句代码可能发生某个==编译时异常==，不处理编译不通过，但是在当前方法体中可能不适合处理或无法给出合理的处理方式，就可以通过throws在方法签名中声明该方法可能会发生xx异常，需要调用者处理。

声明异常格式：

修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2...{ }

在throws后面可以写多个异常类型，用逗号隔开。

java 复制代码 
public class TestThrowsCheckedException {
    public static void main(String[] args) {
        System.out.println("上课.....");
        try {
            afterClass();//换到这里处理异常
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println("准备提前上课");
        }
        System.out.println("上课.....");
    }

    public static void afterClass() throws InterruptedException {
        for(int i=10; i>=1; i--){
            Thread.sleep(1000);//本来应该在这里处理异常
            System.out.println("距离上课还有：" + i + "分钟");
        }
    }
}
2、throws运行时异常

当然，throws后面也可以写运行时异常类型，只是运行时异常类型，写或不写对于编译器和程序执行来说都没有任何区别。如果写了，唯一的区别就是调用者调用该方法后，使用try...catch结构时，IDEA可以获得更多的信息，需要添加什么catch分支。

java 复制代码 
import java.util.InputMismatchException;
import java.util.Scanner;

public class TestThrowsRuntimeException {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        try {
            System.out.print("请输入第一个整数：");
            int a = input.nextInt();
            System.out.print("请输入第二个整数：");
            int b = input.nextInt();
            int result = divide(a,b);
            System.out.println(a + "/" + b +"=" + result);
        } catch (ArithmeticException | InputMismatchException e) {
            e.printStackTrace();
        } finally {
            input.close();
        }
    }

    public static int divide(int a, int b)throws ArithmeticException{
        return a/b;
    }
}
3、方法重写对于throws要求

方法重写时，对于方法签名是有严格要求的：

（1）方法名必须相同

（2）形参列表必须相同

（3）返回值类型

  • 基本数据类型和void：必须相同

  • 引用数据类型：<=

（4）权限修饰符：>=，而且要求父类被重写方法在子类中是可见的

（5）不能是static，final修饰的方法

（6）throws异常列表要求

  • 如果父类被重写方法的方法签名后面没有 "throws 编译时异常类型"，那么重写方法时，方法签名后面也不能出现"throws 编译时异常类型"。

  • 如果父类被重写方法的方法签名后面有 "throws 编译时异常类型"，那么重写方法时，throws的编译时异常类型必须<=被重写方法throws的编译时异常类型，或者不throws编译时异常。

  • 方法重写，对于"throws 运行时异常类型"没有要求。

java 复制代码 
import java.io.IOException;

public class TestOverride {

}

class Father{
    public void method()throws Exception{
        System.out.println("Father.method");
    }
}
class Son extends Father{
    @Override
    public void method() throws IOException,ClassCastException {
        System.out.println("Son.method");
    }
}

手工抛出异常对象：throw

Java程序的执行过程中如出现异常，会生成一个异常类对象，该异常对象将被提交给Java运行时系统，这个过程称为抛出(throw)异常。异常对象的生成有两种方式：

  • 由虚拟机自动生成：程序运行过程中，虚拟机检测到程序发生了问题，就会在后台自动创建一个对应异常类的实例对象并抛出------自动抛出。

  • 由开发人员手动创建：new 异常类型(【实参列表】);，如果创建好的异常对象不抛出对程序没有任何影响，和创建一个普通对象一样，但是一旦throw抛出，就会对程序运行产生影响了。

使用格式：

throw new 异常类名(参数);

throw语句抛出的异常对象，和JVM自动创建和抛出的异常对象一样。

  • 如果是编译时异常类型的对象，同样需要使用throws或者try...catch处理，否则编译不通过。

  • 如果是运行时异常类型的对象，编译器不提示。

  • 但是无论是编译时异常类型的对象，还是运行时异常类型的对象，如果没有被try..catch合理的处理，都会导致程序崩溃。

throw语句会导致程序执行流程被改变，throw语句是明确抛出一个异常对象，因此它下面的代码将不会执行，如果当前方法没有try...catch处理这个异常对象，throw语句就会代替return语句提前终止当前方法的执行，并返回一个异常对象给调用者。

java 复制代码 
public class TestThrow {
    public static void main(String[] args) {
        try {
            System.out.println(max(4,2,31,1));
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            System.out.println(max(4));
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            System.out.println(max());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static int max(int... nums){
        if(nums == null || nums.length==0){
            throw new IllegalArgumentException("没有传入任何整数，无法获取最大值");
        }
        int max = nums[0];
        for (int i = 1; i < nums.length; i++) {
            if(nums[i] > max){
                max = nums[i];
            }
        }
        return max;
    }
}

自定义异常

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

我们说了Java中不同的异常类,分别表示着某一种具体的异常情况,那么在开发中总是有些异常情况是核心类库中没有定义好的，此时我们需要根据自己业务的异常情况来定义异常类。例如年龄负数问题，考试成绩负数问题等等。

异常类如何定义:

  1. 自定义一个编译时异常类型：自定义类 并继承java.lang.Exception。

  2. 自定义一个运行时异常类型：自定义类 并继承java.lang.RuntimeException。

注意自定义的异常只能通过throw抛出。

自定义异常：

（1）要继承一个异常类型

（2）建议大家提供至少两个构造器，一个是无参构造，一个是(String message)构造器

（3）自定义异常对象只能手动抛出。抛出后由try..catch处理，也可以甩锅throws给调用者处理。

演示自定义异常

java 复制代码 
public class NotTriangleException extends Exception{
    public NotTriangleException() {
    }

    public NotTriangleException(String message) {
        super(message);
    }
}
java 复制代码 
public class Triangle {
    private double a;
    private double b;
    private double c;

    public Triangle(double a, double b, double c) throws NotTriangleException {
        if(a<=0 || b<=0 || c<=0){
            throw new NotTriangleException("三角形的边长必须是正数");
        }
        if(a+b<=c || b+c<=a || a+c<=b){
            throw new NotTriangleException(a+"," + b +"," + c +"不能构造三角形，三角形任意两边之后必须大于第三边");
        }
        this.a = a;
        this.b = b;
        this.c = c;
    }

    public double getA() {
        return a;
    }

    public void setA(double a) throws NotTriangleException{
        if(a<=0){
            throw new NotTriangleException("三角形的边长必须是正数");
        }
        if(a+b<=c || b+c<=a || a+c<=b){
            throw new NotTriangleException(a+"," + b +"," + c +"不能构造三角形，三角形任意两边之后必须大于第三边");
        }
        this.a = a;
    }

    public double getB() {
        return b;
    }

    public void setB(double b) throws NotTriangleException {
        if(b<=0){
            throw new NotTriangleException("三角形的边长必须是正数");
        }
        if(a+b<=c || b+c<=a || a+c<=b){
            throw new NotTriangleException(a+"," + b +"," + c +"不能构造三角形，三角形任意两边之后必须大于第三边");
        }
        this.b = b;
    }

    public double getC() {
        return c;
    }

    public void setC(double c) throws NotTriangleException {
        if(c<=0){
            throw new NotTriangleException("三角形的边长必须是正数");
        }
        if(a+b<=c || b+c<=a || a+c<=b){
            throw new NotTriangleException(a+"," + b +"," + c +"不能构造三角形，三角形任意两边之后必须大于第三边");
        }
        this.c = c;
    }

    @Override
    public String toString() {
        return "Triangle{" +
                "a=" + a +
                ", b=" + b +
                ", c=" + c +
                '}';
    }
}
java 复制代码 
public class TestTriangle {
    public static void main(String[] args) {
        Triangle t = null;
        try {
            t = new Triangle(2,2,3);
            System.out.println("三角形创建成功：");
            System.out.println(t);
        } catch (NotTriangleException e) {
            System.err.println("三角形创建失败");
            e.printStackTrace();
        }

        try {
            if(t != null) {
                t.setA(1);
            }
            System.out.println("三角形边长修改成功");
        } catch (NotTriangleException e) {
            System.out.println("三角形边长修改失败");
            e.printStackTrace();
        }
    }
}
相关推荐
吴冰_hogan14 小时前
JVM（Java虚拟机）的组成部分详解
java·开发语言·jvm
东阳马生架构1 天前
JVM实战—1.Java代码的运行原理
jvm
ThisIsClark1 天前
【后端面试总结】深入解析进程和线程的区别
java·jvm·面试
王佑辉1 天前
【jvm】内存泄漏与内存溢出的区别
jvm
大G哥1 天前
深入理解.NET内存回收机制
jvm·.net
泰勒今天不想展开1 天前
jvm接入prometheus监控
jvm·windows·prometheus
东阳马生架构2 天前
JVM简介—3.JVM的执行子系统
jvm
程序员志哥2 天前
JVM系列(十三) -常用调优工具介绍
jvm
后台技术汇2 天前
JavaAgent技术应用和原理：JVM持久化监控
jvm
热门推荐
0119个Web前端交互式3D JavaScript框架和库02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04RAG 实践- Ollama+RagFlow 部署本地知识库05【一文读懂】NTN（非地面网络）技术介绍06(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明07Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO08组基轨迹建模 GBTM的介绍与实现（Stata 或 R）09Docker 夺命连环 15 问10大模型国产化适配7-华为昇腾LLM落地可选解决方案（MindFormers、ModelLink、MindIE）