Java异常

最新推荐文章于 2024-10-16 10:13:45 发布
最新推荐文章于 2024-10-16 10:13:45 发布
阅读量860 收藏 20
点赞数 25
文章标签： java python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41312759/article/details/135191720
版权

1. 请解释Java中的异常处理机制。

Java中的异常处理机制是一种通过使用异常对象来管理程序运行时错误的机制。当程序发生错误时，它会生成一个异常对象，该对象包含有关错误的信息。然后，程序可以使用异常处理机制来捕获和处理这些异常。

Java中的异常处理机制包括以下几个关键概念：

  1. 异常类：Java提供了许多预定义的异常类，每个异常类都代表一种特定的错误类型。例如，FileNotFoundException表示找不到文件的错误，ArithmeticException表示算术错误等。

  2. try-catch语句：try-catch语句用于捕获和处理异常。它的基本结构如下：

    try {
    // 可能会抛出异常的代码块
} catch (ExceptionType e) {
    // 处理异常的代码块
}

    在try块中，你可以编写可能会抛出异常的代码。如果在执行过程中发生了异常，那么控制流将跳转到与该异常类型匹配的catch块中。在catch块中，你可以编写处理异常的代码。

  3. finally语句：finally语句是可选的，它用于指定无论是否发生异常，都会执行的代码块。通常，在finally块中会关闭打开的资源或进行清理操作。finally块的结构如下：

    try {
    // 可能会抛出异常的代码块
} catch (ExceptionType e) {
    // 处理异常的代码块
} finally {
    // 无论是否发生异常都会执行的代码块
}

  4. throw语句：throw语句用于手动抛出异常。你可以通过throw关键字后跟一个异常对象来抛出异常。例如：

    if (x < 0) {
    throw new IllegalArgumentException("x不能为负数");
}

  5. throws关键字：throws关键字用于声明一个方法可能抛出的异常类型。如果一个方法可能抛出多个异常类型，可以使用逗号分隔它们。例如：

    public void divide(int a, int b) throws ArithmeticException, IllegalArgumentException {
    if (b == 0) {
        throw new ArithmeticException("除数不能为0");
    } else if (a < 0 || b < 0) {
        throw new IllegalArgumentException("参数不能为负数");
    } else {
        // 正常执行除法操作
    }
}

2. 请列举Java中常见的异常类型，并简要描述它们的作用。

Java中常见的异常类型有很多，以下是一些常见的异常类型及其简要描述：

  1. NullPointerException（空指针异常）：当试图访问一个空对象的成员时抛出。通常发生在未初始化的对象上调用方法或访问属性时。
    NullPointerException（空指针异常）是指在程序运行过程中，试图访问一个空对象引用的成员或方法时抛出的异常。下面是一个示例：
public class NullPointerExceptionExample {
    public static void main(String[] args) {
        String str = null;
        try {
            System.out.println(str.length());
        } catch (NullPointerException e) {
            System.out.println("发生了空指针异常");
            e.printStackTrace();
        }
    }
}

在这个示例中，我们创建了一个名为str的字符串变量，并将其值设置为null。然后，我们尝试调用str.length()方法来获取字符串的长度。由于str是null，因此会抛出NullPointerException异常。在catch块中，我们捕获了这个异常并打印了一条错误消息。
2. ArrayIndexOutOfBoundsException（数组下标越界异常）：当访问数组时使用的索引超出数组的有效范围时抛出。
ArrayIndexOutOfBoundsException（数组下标越界异常）是指在程序运行过程中，试图访问数组中不存在的索引时抛出的异常。下面是一个Java代码示例：

public class ArrayIndexOutOfBoundsExceptionExample {
    public static void main(String[] args) {
        int[] arr = new int[5];
        System.out.println(arr[5]); // 这里会抛出ArrayIndexOutOfBoundsException
    }
}

在这个示例中，我们创建了一个长度为5的整数数组arr，然后尝试访问索引为5的元素。由于数组的索引是从0开始的，所以有效的索引范围是0到4。当我们尝试访问索引为5的元素时，会抛出ArrayIndexOutOfBoundsException异常。
3. ClassNotFoundException（类未找到异常）：当尝试加载一个不存在的类时抛出。

  1. FileNotFoundException（文件未找到异常）：当试图打开一个不存在的文件时抛出。

  2. IOException（输入输出异常）：当发生I/O操作错误时抛出，如读写文件、网络通信等。

  3. ArithmeticException（算术异常）：当执行非法的算术操作时抛出，如除以0、求负数的平方根等。

  4. NumberFormatException（数字格式异常）：当将一个字符串转换为数字时，如果该字符串不符合数字格式规范，则抛出此异常。

  5. SQLException（数据库操作异常）：当执行数据库操作时发生错误时抛出，如连接数据库失败、执行SQL语句错误等。

  6. NoSuchMethodException（方法未找到异常）：当调用一个不存在的方法时抛出。

  7. InstantiationException（实例化异常）：当试图通过Class对象的newInstance()方法创建一个类的实例，而该类是一个抽象类、接口、数组类或基本数据类型时抛出。

  8. IllegalAccessException（非法访问异常）：当试图访问一个不允许访问的成员时抛出，如私有成员、受保护成员等。

  9. OutOfMemoryError（内存溢出错误）：当Java虚拟机无法为对象分配足够的内存空间时抛出。

这些只是Java中的一部分常见异常类型，实际上还有很多其他类型的异常。在编写程序时，应根据具体情况选择合适的异常类型进行处理。

3. 请解释Java中的受检异常（Checked Exception）和非受检异常（Unchecked Exception）。

在Java中，异常分为受检异常（Checked Exception）和非受检异常（Unchecked Exception）。

  1. 受检异常（Checked Exception）：受检异常是指在编译时必须处理的异常。这些异常通常是由方法调用或操作引起的，例如文件I/O、网络连接等。为了处理这些异常，我们需要使用try-catch语句块来捕获并处理它们。例如：
import java.io.FileInputStream;
import java.io.IOException;

public class CheckedExceptionExample {
    public static void main(String[] args) {
        try {
            FileInputStream fis = new FileInputStream("non_existent_file.txt");
        } catch (IOException e) {
            System.out.println("发生IO异常： " + e.getMessage());
        }
    }
}

在上面的示例中，我们尝试打开一个不存在的文件，这将导致FileInputStream构造函数抛出FileNotFoundException，这是一个受检异常。我们使用try-catch语句块捕获并处理这个异常。

  1. 非受检异常（Unchecked Exception）：非受检异常是指在编译时不需要处理的异常。这些异常通常是由程序逻辑错误引起的，例如空指针引用、数组越界等。由于编译器不会强制要求处理这些异常，因此我们通常不使用try-catch语句块来捕获它们。例如：
public class UncheckedExceptionExample {
    public static void main(String[] args) {
        String str = null;
        System.out.println(str.length()); // 这里会抛出NullPointerException，但编译器不会强制要求处理它
    }
}

在上面的示例中，我们尝试获取一个空字符串的长度，这将导致NullPointerException。虽然这是一个非受检异常，但由于编译器不会强制要求处理它，所以我们不需要使用try-catch语句块来捕获它。

4. 请解释Java中的try-catch-finally语句，以及它们的执行顺序。

在Java中，try-catch-finally语句用于处理程序运行过程中可能出现的异常。它们的作用如下：

  1. try：将可能抛出异常的代码放在try块中。如果try块中的代码没有抛出异常，那么catch和finally块将被跳过。
  2. catch：用于捕获try块中抛出的异常。可以有多个catch块，每个catch块处理一种特定类型的异常。当try块中的代码抛出异常时，与该异常类型匹配的catch块将被执行。
  3. finally：无论是否发生异常，finally块中的代码都将被执行。通常用于资源的释放，如关闭文件、数据库连接等。

执行顺序如下：

  1. 首先执行try块中的代码。
  2. 如果try块中的代码没有抛出异常，那么跳过catch和finally块。
  3. 如果try块中的代码抛出了异常，那么与该异常类型匹配的catch块将被执行。如果没有匹配的catch块，异常将继续向上抛出，直到遇到一个catch块或者到达方法的顶层。
  4. 无论是否发生异常，finally块中的代码都将被执行。

举例说明：

public class TryCatchFinallyExample {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3};
        try {
            System.out.println(numbers[5]); // 这里会抛出ArrayIndexOutOfBoundsException异常
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("捕获到数组越界异常：" + e.getMessage());
        } finally {
            System.out.println("这是finally块，无论是否发生异常都会执行");
        }
    }
}

输出结果：

捕获到数组越界异常：Index 5 out of bounds for length 3
这是finally块，无论是否发生异常都会执行

5. 请解释Java中的异常链（Exception Chaining），并给出一个示例。

在Java中，异常链（Exception Chaining）是指一个异常对象可以持有另一个异常对象的引用。当一个异常被捕获并处理时，我们可以创建一个新的异常对象，并将原始异常作为新异常的一个属性，这样我们就可以保留原始异常的堆栈跟踪信息。

下面是一个简单的示例：

public class ExceptionChainingExample {
    public static void main(String[] args) {
        try {
            methodThatThrowsException();
        } catch (Exception e) {
            // 创建一个新的异常对象，并将原始异常作为其原因
            Exception newException = new Exception("新的异常消息", e);
            throw newException;
        }
    }

    public static void methodThatThrowsException() throws Exception {
        try {
            // 这里可能会抛出一些异常
            throw new Exception("原始异常消息");
        } catch (Exception e) {
            // 捕获到异常后，创建一个新的异常对象，并将原始异常作为其原因
            throw new Exception("方法内部的异常消息", e);
        }
    }
}

在这个例子中，methodThatThrowsException方法内部捕获了一个异常，并创建了一个新的异常对象，将原始异常作为新异常的原因。然后，这个新的异常对象被抛出，并在main方法中被捕获。通过这种方式，我们保留了原始异常的堆栈跟踪信息，这有助于调试和错误追踪。

6. 请解释Java中的自定义异常（Custom Exception），并给出一个简单的自定义异常类示例。

在Java中，自定义异常是指用户根据实际需求创建的异常类。这些异常类通常继承自Java内置的Exception类或其子类。自定义异常可以用于表示特定于应用程序的错误情况，以便在程序中进行更精确的错误处理和提示。

下面是一个简单的自定义异常类的示例：

// 自定义异常类
public class CustomException extends Exception {
    private int errorCode;

    public CustomException(String message, int errorCode) {
        super(message); // 调用父类构造函数，传递错误消息
        this.errorCode = errorCode; // 设置错误代码
    }

    public int getErrorCode() {
        return errorCode; // 获取错误代码
    }
}

在上面的示例中，我们定义了一个名为CustomException的自定义异常类，它继承了Exception类。该类包含一个私有成员变量errorCode，用于存储错误代码。通过构造函数，我们可以传递错误消息和错误代码给自定义异常对象。还提供了一个getErrorCode()方法来获取错误代码。

使用自定义异常时，可以在需要抛出异常的地方使用throw关键字，并创建一个新的CustomException对象，将错误消息和错误代码传递给它。例如：

public void processData(int data) throws CustomException {
    if (data < 0) {
        throw new CustomException("数据不能为负数", 1001); // 抛出自定义异常
    }
    // 其他处理数据的代码...
}

在上面的示例中，processData方法接受一个整数参数data，如果data小于0，则抛出一个带有错误消息和错误代码的CustomException异常。

当调用processData方法时，可以使用try-catch块来捕获并处理自定义异常。例如：

try {
    processData(-5); // 传入一个负数作为参数
} catch (CustomException e) {
    System.out.println("发生自定义异常：" + e.getMessage());
    System.out.println("错误代码：" + e.getErrorCode());
}

在上面的示例中，我们调用了processData方法并传入了一个负数作为参数。由于条件不满足，会抛出CustomException异常。然后，我们在catch块中捕获异常并打印出错误消息和错误代码。

7. 请解释Java中的运行时异常（Runtime Exception），并列举一些常见的运行时异常。

在Java中，运行时异常（Runtime Exception）是那些可能在程序运行过程中抛出的异常。这些异常通常是由编程错误引起的，例如数组越界、空指针引用等。与编译时异常不同，运行时异常不需要显式地处理，因为它们在编译阶段不会被检查。

以下是一些常见的运行时异常：

  1. NullPointerException：当应用程序试图在需要对象的地方使用null时，就会抛出这个异常。
  2. ArrayIndexOutOfBoundsException：当访问数组元素时，如果索引超出了数组的范围，就会抛出这个异常。
  3. ArithmeticException：当执行算术运算时，如果发生除以零或其他算术错误，就会抛出这个异常。
  4. IllegalArgumentException：当方法接收到非法或不适当的参数时，就会抛出这个异常。
  5. ClassCastException：当试图将一个对象转换为不兼容的类型时，就会抛出这个异常。
  6. NumberFormatException：当尝试将字符串解析为数字时，如果字符串的格式不正确，就会抛出这个异常。
  7. IOException：当输入/输出操作失败或中断时，就会抛出这个异常。
  8. SQLException：当执行数据库操作时，如果发生错误，就会抛出这个异常。
  9. NoSuchElementException：当试图访问集合中不存在的元素时，就会抛出这个异常。
  10. UnsupportedOperationException：当请求的操作不受支持时，就会抛出这个异常。

以下是一个示例代码，演示了如何捕获和处理运行时异常：

public class RuntimeExceptionExample {
    public static void main(String[] args) {
        try {
            int result = divide(10, 0);
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.err.println("Error: " + e.getMessage());
        }
    }

    public static int divide(int a, int b) throws ArithmeticException {
        if (b == 0) {
            throw new ArithmeticException("Division by zero is not allowed");
        }
        return a / b;
    }
}

在上面的示例中，我们定义了一个名为divide的方法，该方法接受两个整数参数并返回它们的商。如果除数为零，我们抛出一个ArithmeticException异常。在main方法中，我们使用try-catch块来捕获和处理这个异常。

8. 请解释Java中的断言（Assertion）机制，并说明如何使用它进行调试。

在Java中，断言（Assertion）是一种用于调试和测试程序的机制。它允许程序员在代码中插入一些条件语句，以验证程序的假设是否成立。如果断言的条件为真，则程序继续执行；如果条件为假，则抛出一个AssertionError异常，并终止程序的执行。

使用断言可以帮助开发人员在开发过程中发现潜在的问题，例如逻辑错误或数据不一致。通过在关键位置插入断言语句，可以确保程序的正确性，并在出现问题时提供有用的错误信息。

要使用断言进行调试，需要启用断言功能。默认情况下，断言是禁用的，需要在运行时添加参数-ea来启用它们。例如：

java -ea MyProgram

在上面的命令中，-ea参数表示启用断言。

要在代码中使用断言，可以使用assert关键字。以下是一个简单的示例：

public class AssertionExample {
    public static void main(String[] args) {
        int age = 18;
        assert age >= 18 : "年龄必须大于等于18岁"; // 断言年龄大于等于18岁
        System.out.println("程序继续执行");
    }
}

在上面的示例中，我们使用assert关键字来检查变量age是否大于等于18岁。如果条件为真，则程序继续执行；如果条件为假，则抛出一个AssertionError异常，并显示指定的错误消息。

需要注意的是，断言主要用于开发和测试阶段，不应该在生产环境中使用。在发布应用程序之前，应该将断言语句全部删除或禁用断言功能。

9. 请解释Java中的异常处理最佳实践，包括如何处理异常、如何记录异常信息等。

在Java中，异常处理是一个重要的部分。以下是一些关于如何处理和记录异常的最佳实践：

  1. 使用try-catch块: 当可能会抛出异常的代码放在try块中时，如果该代码确实抛出了异常，那么控制流就会立即转到相应的catch块。
try {
    // 可能抛出异常的代码
} catch (ExceptionType e) {
    // 处理异常的代码
}
  1. 捕获具体的异常类型: 尽量捕获具体的异常类型，而不是所有的异常类型。这样可以避免捕获到你并不打算处理的异常。
try {
    // 可能抛出异常的代码
} catch (IOException e) {
    // 处理IO异常的代码
} catch (NullPointerException e) {
    // 处理空指针异常的代码
}
  1. 不要忽略异常: 如果你选择捕获异常，那么你应该至少打印出异常信息，或者以某种方式记录下来。这样可以帮助你了解程序出了什么问题。
try {
    // 可能抛出异常的代码
} catch (Exception e) {
    e.printStackTrace(); // 打印异常堆栈跟踪
}
  1. 不要吞掉异常: 如果一个方法声明它可能会抛出一个检查型异常，那么这个方法应该要么处理这个异常，要么再次抛出这个异常。如果你选择吞掉异常，那么调用这个方法的代码将无法知道发生了什么问题。
public void myMethod() throws Exception {
    try {
        // 可能抛出异常的代码
    } catch (Exception e) {
        throw new Exception("An error occurred", e); // 重新抛出异常
    }
}
  1. 使用finally块: 无论是否发生异常，finally块中的代码总是会被执行。这通常用于关闭资源，如文件或数据库连接。
try {
    // 可能抛出异常的代码
} catch (Exception e) {
    // 处理异常的代码
} finally {
    // 清理资源的代码
}

以上就是在Java中处理和记录异常的一些最佳实践。

10. 请编写一个Java程序，演示如何使用try-with-resources语句自动关闭资源。

在Java 7及以上版本中，可以使用try-with-resources语句自动关闭资源。这种语句确保了每个资源在语句结束时都将被关闭。

以下是一个示例程序，演示如何使用try-with-resources语句自动关闭资源：

import java.io.*;

public class TryWithResourcesExample {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("test.txt");
             BufferedReader br = new BufferedReader(new InputStreamReader(fis))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在这个例子中，我们打开了一个名为"test.txt"的文件，并使用BufferedReader读取文件内容。由于FileInputStream和BufferedReader都实现了AutoCloseable接口，因此它们都可以在try-with-resources语句中使用。当try块执行完毕后，无论是否发生异常，这两个资源都会被自动关闭。

11. 请编写一个Java程序，演示如何使用Throwable类的printStackTrace()方法打印异常堆栈信息。

以下是一个Java程序，演示如何使用Throwable类的printStackTrace()方法打印异常堆栈信息：

public class Main {
    public static void main(String[] args) {
        try {
            int result = divide(10, 0);
        } catch (ArithmeticException e) {
            e.printStackTrace();
        }
    }

    public static int divide(int a, int b) throws ArithmeticException {
        return a / b;
    }
}

在这个程序中，我们首先在main函数中尝试执行一个可能会抛出异常的操作（除以零）。当这个操作真的抛出了ArithmeticException异常时，我们捕获这个异常并调用它的printStackTrace()方法来打印出异常的堆栈信息。

printStackTrace()方法会打印出异常的类型、消息以及导致异常的代码位置。这对于调试和理解异常的来源非常有用。

12. 请编写一个Java程序，演示如何使用Thread类的setDefaultUncaughtExceptionHandler()方法设置默认的未捕获异常处理器。

在Java中，我们可以使用Thread类的setDefaultUncaughtExceptionHandler()方法来设置默认的未捕获异常处理器。以下是一个简单的示例：

public class Main {
    public static void main(String[] args) {
        // 创建一个新的线程
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                // 抛出一个未捕获的异常
                throw new RuntimeException("这是一个未捕获的异常");
            }
        });

        // 设置默认的未捕获异常处理器
        thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
            @Override
            public void uncaughtException(Thread t, Throwable e) {
                System.out.println("线程 " + t.getName() + " 发生了未捕获的异常： " + e.getMessage());
            }
        });

        // 启动线程
        thread.start();
    }
}

在这个程序中，我们首先创建了一个新的线程，并在该线程中抛出了一个未捕获的异常。然后，我们使用setDefaultUncaughtExceptionHandler()方法设置了一个新的未捕获异常处理器，该处理器将在发生未捕获的异常时被调用。最后，我们启动了线程。

当线程抛出未捕获的异常时，我们的未捕获异常处理器将被调用，并打印出一条消息，指出哪个线程发生了未捕获的异常以及异常的消息。

13. 请编写一个Java程序，演示如何使用synchronized关键字实现线程同步。

在Java中，我们可以使用synchronized关键字来同步线程。以下是一个简单的示例，演示了如何使用synchronized关键字实现线程同步：

public class SynchronizedExample {
    private int count = 0;

    // 使用synchronized关键字修饰方法
    public synchronized void incrementCount() {
        count++;
        System.out.println("当前计数值： " + count);
    }

    public static void main(String[] args) {
        SynchronizedExample example = new SynchronizedExample();

        // 创建两个线程，并启动它们
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.incrementCount();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.incrementCount();
            }
        });

        thread1.start();
        thread2.start();
    }
}

在这个例子中，我们有一个名为SynchronizedExample的类，它有一个私有变量count和一个同步方法incrementCount()。我们使用synchronized关键字修饰incrementCount()方法，这样在同一时间只能有一个线程访问这个方法。

在main方法中，我们创建了两个线程，它们都尝试调用incrementCount()方法。由于incrementCount()方法是同步的，所以这两个线程将按顺序执行，避免了并发问题。

14. 请编写一个Java程序，演示如何使用wait()和notify()方法实现线程间的通信。

以下是一个Java程序，演示了如何使用wait()和notify()方法实现线程间的通信。

class SharedObject {
    private boolean isDataReady = false;

    public synchronized void produceData() throws InterruptedException {
        while (isDataReady) {
            wait();
        }
        System.out.println("生产数据...");
        isDataReady = true;
        notifyAll();
    }

    public synchronized void consumeData() throws InterruptedException {
        while (!isDataReady) {
            wait();
        }
        System.out.println("消费数据...");
        isDataReady = false;
        notifyAll();
    }
}

class ProducerThread extends Thread {
    private SharedObject sharedObject;

    public ProducerThread(SharedObject sharedObject) {
        this.sharedObject = sharedObject;
    }

    @Override
    public void run() {
        try {
            sharedObject.produceData();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class ConsumerThread extends Thread {
    private SharedObject sharedObject;

    public ConsumerThread(SharedObject sharedObject) {
        this.sharedObject = sharedObject;
    }

    @Override
    public void run() {
        try {
            sharedObject.consumeData();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        SharedObject sharedObject = new SharedObject();
        ProducerThread producerThread = new ProducerThread(sharedObject);
        ConsumerThread consumerThread = new ConsumerThread(sharedObject);
        producerThread.start();
        consumerThread.start();
    }
}

在这个程序中，我们创建了一个共享对象SharedObject，它有一个布尔变量isDataReady来表示是否有数据准备好。生产者线程调用produceData()方法时，如果isDataReady为真，则线程会调用wait()方法进入等待状态；消费者线程调用consumeData()方法时，如果isDataReady为假，则线程也会调用wait()方法进入等待状态。当生产者线程生产完数据后，它会将isDataReady设置为真，并调用notifyAll()方法唤醒所有正在等待的线程。同样，当消费者线程消费完数据后，它也会将isDataReady设置为假，并调用notifyAll()方法唤醒所有正在等待的线程。

15. 请编写一个Java程序，演示如何使用Semaphore类实现信号量控制。

在Java中，Semaphore类是一个计数信号量，用于管理一组资源。它维护了一个许可集，如果调用acquire()方法时许可可用，则获取一个许可并返回true；否则，如果许可不可用，则阻塞直到有一个许可变得可用。

以下是一个使用Semaphore类实现信号量控制的简单示例：

import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    // 创建一个具有3个许可的信号量
    Semaphore semaphore = new Semaphore(3);

    public void accessResource(int id) {
        try {
            // 尝试获取一个许可
            semaphore.acquire();
            System.out.println("线程 " + id + " 获取到了一个许可");
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 释放许可
            semaphore.release();
            System.out.println("线程 " + id + " 释放了一个许可");
        }
    }

    public static void main(String[] args) {
        SemaphoreExample example = new SemaphoreExample();

        // 创建并启动5个线程，每个线程都试图访问共享资源
        for (int i = 1; i <= 5; i++) {
            new Thread(() -> example.accessResource(i)).start();
        }
    }
}

在这个例子中，我们创建了一个具有3个许可的信号量。然后，我们创建了5个线程，每个线程都试图获取一个许可来访问共享资源。由于我们的信号量只有3个许可，所以当第4个线程获取到许可并开始访问资源时，第5个线程将无法获取许可并被阻塞，直到第4个线程释放许可。

编织幻境的妖
关注
Java 异常处理 -- Java 语言的异常、异常链与断言
栗筝i的博客
06-13 3346
世界上存在永远不会出错的程序吗？也许这只会出现在程序员的梦中。随着编程语言和软件的诞生，异常情况就如影随形地纠缠着我们，只有正确处理好意外情况，才能保证程序的可靠性。
java 反射获取类的属性_java反射获取类属性问题。
weixin_36444881的博客
02-12 85
代码：public static List select(String sql, String o)throws SQLException, ClassNotFoundException, InstantiationException, IllegalAccessException {Class c = Class.forName(o);Field[] fls = c.getDeclaredFie...
111111
jygkhkjhk的博客
12-30 6622
1 【单选题】下列选项中,可以实现警告框的是()。 窗体顶端 A、alert() B、prompt() C、document.write() D、console.log() 2 【单选题】下面()标签可在页面中直接嵌入JavaScript。 窗体顶端 A、7 【单选题】下面链接外部JavaScript正确的是()。 A、 D、 8 【单选题】下列选项中,不能编辑JavaScript程序的是()。 A、记事本 B、Dreamweaver C、Photoshop D、WebStorm 9 【单选题】以下代码是通
第五章 JavaScript 对象
m0_46844278的博客
04-30 2905
JavaScript前端开发教程 目录： 第五章 JavaScript 对象 面向对象概述 对象的定义 对象成员访问与遍历 深拷贝与浅拷贝 构造函数 String对象 Number对象 Math对象 Date对象 【案例】制作年历 错误处理 代码调试 原型 继承 静态成员 属性搜索原则 原型链 【案例】表单生成器 &&：习题+答案 **链接：第五章 JavaScript 对象 ...
JavaScript中的六种错误类型
choujiaodie3389的博客
09-22 257
刚入前端坑，英语又不太好的同学，是不是还在为控制台的错误抓耳挠腮？今天就带大家看一看JavaScript中常见的错误类型。 js中的控制台的报错信息主要分为两大类，第一类是语法错误，这一类错误在预解析的过程中如果遇到，就会导致整个js文件都无法执行。另一类错误统称为异常，这一类的错误会...
js报错类型（6种错误类型）
Kuroko's Development Notes
03-08 7077
js中的控制台的报错信息主要分为两大类，第一类是语法错误，这一类错误在预解析的过程中如果遇到，就会导致整个js文件都无法执行。另一类错误统称为异常，这一类的错误会导致在错误出现的那一行之后的代码无法执行，但在那一行之前的代码不会受到影响。 SyntaxError // SyntaxError: 语法错误 // 1) 变量名不符合规范 var 1 // Uncaught Syntax...
java异常处理练习题
08-17
java异常练习题，北大青鸟学士后课后练习，主要是异常处理的小测验
关于Java异常处理的几条建议_动力节点Java学院整理
08-30
Java 异常处理机制详解 Java 异常处理是 Java 语言中的一种机制，用于处理程序中的异常情况。Java 提供了抛出异常、捕捉异常和 finally 语句的使用来处理程序异常。下面是关于 Java 异常处理的几条建议： 建议 1: ...
Java异常的性能分析
03-23
Java异常的性能分析.在Java中抛异常的性能是非常差的。通常来说，抛一个异常大概会消耗100到1000个时钟节拍。 　在Java中抛异常的性能是非常差的。通常来说，抛一个异常大概会消耗100到1000个时钟节拍。 　通常是...
Python基础学习之异常操作总结
weixin_47139649的博客
10-12 4964
Python基础学习之异常操作总结 文章目录Python基础学习之异常操作总结1. 异常捕获1.1 捕获所有异常1.2 捕捉指定异常1.3 捕捉多个异常1.3.1 不区分优先级1.3.2 区分优先级1.4 异常中的else1.5 异常中的finally2. 用户自定义异常_raise 主动触发异常3. 查看异常位置_traceback模块 在Python运行遇到异常时，程序会终止；而在我们编程过程中，错误是不可避免的，这时我们需要捕捉到异常，还需要程序继续运行；这时我们就需要根据异常Traceback到出错
异常处理程序应该提供上下文信息并且保留原始异常
踏雁寻花
02-12 3935
Exception handlers should provide some context and preserve the original exception 处理异常时，需要进行两个操作： 1、使用context减缓复制的问题 2、保留原始异常信息，进行堆栈问题的追踪（ stack trace ） 看一些例子： try { /* ...
JavaScript基础--错误类型及错误处理
zxn200125的博客
11-17 221
js中的错误类型及错误处理相关知识
JavaScript Error类型
FAFA的博客
08-18 1140
错误类型 SyntaxError解析错误 SyntaxError是解析代码时发生的语法错误 // 变量名错误 var 1a; // 缺少括号 console.log 'hello'); RefenrceError引用错误 ReferenceError是引用一个不存在的变量时发生的错误。将一个值分配给无法分配的对象，比如对函数的运行结果或者this赋值。 a // Uncau...
Java中几种常见的异常抛出类的说明
Mr_Lee—胜利的博客
03-30 4691
1.常见的异常现象： 空指针异常类：NullPointerException 类型强制转换异常：ClassCastException 数组负下标异常：NegativeArrayException 数组下标越界异常：ArrayIndexOutOfBoundsException 违背安全原则异常：SecturityException 文件已结束异常：EOFExcep
Java中几种常见的异常抛出类的说明！！！！
LiMing_0820的博客
10-17 8796
这几天都在搞java代码，但是常常碰见未知的异常抛出错误，这里记录一下，方便日后的查看与总结： 1.常见的异常现象： 空指针异常类：NullPointerException 类型强制转换异常：ClassCastException 数组负下标异常：NegativeArrayException 数组下标越界异常：ArrayIndexOutOfBoundsException
究竟 javascript 错误处理有哪些类型？
weixin_34037515的博客
10-19 181
有时候，在自己封装的工具函数中，不传参或传入了错误类型的参数，也要适当的抛出一些错误以示警告；使用框架不正常情况下也会抛出错误，如果对错误一无所知，便无从下手调试。综合上述，了解错误的处理机制是多么必要。 以下是笔者归纳总结，如有误之处，欢迎指出。 错误构造函数 javascript规范中总共有8中错误类型构造函数 Error -- 错误对象 SyntaxError --解析过程语法错误 Type...
JS常见错误类型
weixin_45240168的博客
11-09 1730
由于我在写js的时候总是遇到各种错误，根据现在的英语水平读不懂错误的意思，没有头绪解决，故在这里总结一下。在编码的过程中出现报错很常见，重要的是可以读取错误信息，明白是哪里出了问题，然后才能从根源上解决问题。 1、常见的错误类型 1.1 TypeError（类型错误） 当函数的操作数或参数的类型不是操作符或函数所期望的类型时，将抛出一个TypeError类型错误。MDN文档有详细介绍：https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Refere
【C++刷题】力扣-#121-买卖股票的最佳时机
最新发布
会写代码的饭桶
10-16 245
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
Java异常体系详解
Java异常是程序运行时发生的问题，这些异常分为两种主要类型：Error和Exception。Error通常表示严重的系统级问题，而Exception是程序可以预见和处理的异常情况。 1. **算术异常类：ArithmeticExecption** - 当执行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值