返回专栏
· 18 分钟阅读

异常处理(Exception Handling)


一、什么是异常处理?

异常处理(Exception Handling)是一种用于检测、传递和处理程序执行过程中非正常情况的控制机制。

程序运行时可能遇到各种无法按预期完成的情况:

  • 文件不存在或没有访问权限。
  • 网络连接失败或请求超时。
  • 数组越界或空指针访问。
  • 类型转换失败。
  • 数据库事务执行失败。
  • 内存分配失败。
  • 用户输入不符合预期。

如果程序只按照正常执行路径运行,就无法可靠地应对这些情况。

异常处理机制允许程序将正常业务逻辑与异常处理逻辑分离。当异常发生时,运行时系统根据异常类型和调用栈寻找合适的处理位置。

1. 异常与错误的区别

异常(Exception)和错误(Error)在日常开发中经常被混用,但在技术语义上并不完全相同。

概念 含义 示例
异常(Exception) 程序执行过程中出现的非正常情况 文件不存在、网络超时
错误(Error) 更广泛的失败状态,可能来自程序缺陷或运行环境 内存不足、系统资源耗尽
缺陷(Bug) 程序设计或实现中的错误 数组索引计算错误
失败(Failure) 程序或系统未能完成预期功能 请求处理失败、服务不可用

不同语言对 Exception 和 Error 的分类并不一致。

例如:

  • Java 将 Exception 和 Error 都定义为 Throwable 的子类。
  • Python 使用 BaseException 作为异常体系的根类型。
  • JavaScript 使用 Error 及其派生类型表达大多数异常。
  • Go 不采用传统异常体系,主要通过返回 error 表示可预期的失败。

因此,异常和错误的具体含义需要结合语言的异常模型理解。

2. 异常处理解决什么问题?

异常处理主要解决三个问题:

  1. 错误检测:识别程序执行过程中发生的异常情况。
  2. 错误传递:将当前层无法处理的问题传递给上层调用者。
  3. 错误恢复:在合适的位置处理异常,使程序能够继续执行或安全退出。

典型处理过程:

flowchart TD
    A["程序正常执行"] --> B["执行某项操作"]
    B --> C{"是否发生异常?"}
    C -->|"否"| D["继续正常执行"]
    C -->|"是"| E["创建或抛出异常"]
    E --> F["查找异常处理器"]
    F --> G{"是否找到处理器?"}
    G -->|"是"| H["执行异常处理逻辑"]
    G -->|"否"| I["继续向上层传播"]
    I --> J{"是否找到处理器?"}
    J -->|"是"| H
    J -->|"否"| K["异常未捕获,程序或线程终止"]

    style A fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style D fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style E fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style G fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style H fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style I fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style J fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style K fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

二、异常处理的核心组成

不同语言的语法有所区别,但传统异常处理机制通常包含以下组成部分。

1. try:监控可能发生异常的代码

try 用于包围可能产生异常的代码。

try:
    result = 10 / 0

当 try 中的代码正常执行时,程序继续执行后续逻辑。

当发生异常时,程序停止执行当前 try 代码块中剩余的语句,并尝试寻找匹配的异常处理器。

需要注意:

  • try 本身不会处理异常。
  • try 只是标记需要监控的代码区域。
  • 异常是否被处理,取决于是否存在匹配的处理器。

2. throw / raise:主动抛出异常

当程序检测到某种不符合预期的状态时,可以主动抛出异常。

不同语言使用不同关键字:

语言 抛出异常
Python raise
Java throw
JavaScript throw
C# throw
C++ throw

Python 示例:

def withdraw(balance, amount):
    if amount <= 0:
        raise ValueError("金额必须大于 0")

    if amount > balance:
        raise ValueError("余额不足")

    return balance - amount

主动抛出异常通常用于表达当前操作无法继续完成的情况。

需要区分两种情况:

  • 系统产生异常:例如文件打开失败、类型转换失败。
  • 程序主动抛出异常:例如业务规则校验不通过。

主动抛出异常可以将业务约束转化为明确的错误信号。

3. catch / except:捕获并处理异常

捕获异常意味着程序接管异常处理过程,而不是继续让异常向上层传播。

Python 示例:

try:
    result = 10 / 0
except ZeroDivisionError:
    print("不能除以零")

Java 示例:

try {
    int result = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("不能除以零");
}

捕获异常时,应该尽量指定明确的异常类型。

不推荐无差别捕获所有异常:

try:
    process_data()
except Exception:
    pass

这种写法会隐藏真实错误,使程序表面上继续运行,但实际状态可能已经不正确。

4. finally:执行清理逻辑

finally 用于定义无论 try 中是否发生异常,通常都需要执行的清理逻辑。

try:
    file = open("data.txt", "r")
    content = file.read()
except FileNotFoundError:
    print("文件不存在")
finally:
    print("执行清理逻辑")

常见用途:

  • 关闭文件。
  • 释放锁。
  • 关闭数据库连接。
  • 释放其他外部资源。

但需要注意,finally 并不意味着绝对执行。进程被强制终止、运行时崩溃、机器断电等情况,都可能使清理逻辑无法完成。

5. else:异常未发生时执行

部分语言支持 else 子句,例如 Python。

try:
    result = 10 / 2
except ZeroDivisionError:
    print("除数不能为零")
else:
    print("计算成功:", result)
finally:
    print("执行结束")

执行规则:

  • try 中发生异常:匹配对应的 except。
  • try 中没有发生异常:执行 else。
  • 无论是否发生异常:通常都会执行 finally。

else 有助于缩小异常捕获范围,避免将不应该被捕获的代码放进 try 中。

三、异常处理的执行机制

理解异常处理不能只停留在语法层面,还需要理解异常如何在程序运行时传播。

1. 异常传播机制

当一个函数发生异常,但当前函数没有处理该异常时,异常会沿着函数调用关系向上层传播。

例如:

def read_file():
    return open("data.txt", "r")

def process_data():
    file = read_file()
    return file.read()

def main():
    try:
        process_data()
    except FileNotFoundError:
        print("文件不存在")

调用关系:

flowchart TD
    A["main()"] --> B["process_data()"]
    B --> C["read_file()"]
    C --> D["打开文件"]
    D --> E["发生 FileNotFoundError"]
    E --> F["read_file() 未处理"]
    F --> G["传播到 process_data()"]
    G --> H["process_data() 未处理"]
    H --> I["传播到 main()"]
    I --> J["捕获 FileNotFoundError"]

    style A fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style F fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style G fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style H fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style I fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style J fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

这里需要理解一个关键点:

异常传播并不是简单地将错误信息返回给调用者,而是运行时系统根据调用栈寻找能够处理该异常的处理器。

2. 调用栈与异常展开

函数调用通常会形成调用栈(Call Stack)。

每次调用函数时,运行时系统会维护相应的调用信息,例如:

  • 返回地址。
  • 局部变量。
  • 参数信息。
  • 必要的运行时状态。

当异常发生时,运行时系统需要确定:

  1. 当前执行位置是否存在匹配的异常处理器。
  2. 如果不存在,当前函数是否可以退出。
  3. 退出当前函数后,继续检查上一层调用。
  4. 直到找到处理器,或者异常无法被捕获。

这一过程通常称为栈展开(Stack Unwinding)。

flowchart TD
    A["异常发生"] --> B["检查当前栈帧"]
    B --> C{"是否存在匹配处理器?"}
    C -->|"是"| D["展开到处理器所在位置"]
    C -->|"否"| E["执行当前栈帧的清理逻辑"]
    E --> F["销毁当前栈帧"]
    F --> G{"是否还有上层栈帧?"}
    G -->|"是"| B
    G -->|"否"| H["异常未捕获"]

    style A fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style D fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style F fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style G fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style H fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

不同语言的具体实现不同:

  • Java 通常通过运行时异常表等机制定位处理器。
  • C++ 使用异常处理表、运行时展开机制等实现栈展开。
  • Python 通过解释器的异常状态和调用帧机制处理异常传播。
  • JavaScript 引擎在执行上下文中维护异常处理相关状态。

栈展开是理解异常处理的重要基础,尤其关系到资源释放、析构函数执行和程序状态恢复。

3. 异常传播与返回值的区别

异常传播与普通函数返回值有本质区别。

对比维度 返回值 异常
控制流 按照正常调用路径返回 可能跳过中间调用层
调用者处理 通常需要检查返回值 由匹配的异常处理器接管
表达方式 返回数据或错误对象 抛出异常对象或异常状态
使用场景 预期内的结果与失败 需要改变正常控制流的异常情况

例如:

def divide(a, b):
    if b == 0:
        raise ZeroDivisionError("除数不能为零")

    return a / b

与:

def divide(a, b):
    if b == 0:
        return None

    return a / b

第二种写法使用返回值表达失败,但存在一个问题:调用者必须区分 None 究竟表示正常业务结果,还是操作失败。

实际项目中,可以根据语言习惯和业务语义选择异常、错误返回值或结果类型。

四、异常的分类体系

异常分类决定了异常捕获范围、处理策略以及程序的恢复方式。

1. 受检异常与非受检异常

受检异常(Checked Exception)和非受检异常(Unchecked Exception)是 Java 异常体系中的重要概念。

受检异常:

编译器要求调用者显式处理,或者通过方法声明向外传播。

public void readFile() throws IOException {
    FileInputStream input = new FileInputStream("data.txt");
}

调用者需要处理 IOException,或者继续声明向外抛出。

非受检异常:

编译器不强制要求调用者捕获或声明。

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

当 b 为零时,会发生 ArithmeticException,但方法不需要声明该异常。

Java 异常体系:

flowchart TD
    A["Throwable"] --> B["Error"]
    A --> C["Exception"]
    C --> D["RuntimeException"]
    C --> E["其他 Exception 子类"]
    D --> F["非受检异常"]
    E --> G["受检异常"]
    B --> H["通常不建议业务代码捕获"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style F fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style H fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

需要注意:

  • Error 通常表示严重的运行时或环境问题。
  • Exception 表示应用程序可以考虑处理的异常情况。
  • RuntimeException 及其子类属于非受检异常。
  • 其他直接继承 Exception 的异常通常属于受检异常。

受检异常是 Java 的语言设计特征,并不是所有语言都有相同机制。

2. 业务异常与系统异常

在应用程序设计中,还经常按照业务语义区分异常。

类型 含义 示例
业务异常 违反业务规则或业务条件 余额不足、订单状态不允许变更
系统异常 系统运行或外部依赖出现问题 数据库连接失败、文件读取失败
编程异常 程序实现存在缺陷 空指针、数组越界、非法状态

例如:

class InsufficientBalanceError(Exception):
    pass


def withdraw(balance, amount):
    if amount > balance:
        raise InsufficientBalanceError("账户余额不足")

    return balance - amount

自定义业务异常可以让错误表达更加清晰,也便于上层根据异常类型制定不同的处理策略。

3. 同步异常与异步异常

同步异常通常发生在当前执行流程中,并通过当前调用链传播。

异步场景中的异常则更加复杂。

例如:

  • JavaScript 的 Promise 拒绝状态。
  • Python 的异步协程异常。
  • Java CompletableFuture 中的异常完成状态。
  • Go 并发任务中的错误返回与 panic。

异步任务的异常不一定能够被创建任务时所在位置的普通 try-catch 捕获。

JavaScript 示例:

async function loadData() {
    try {
        const response = await fetch("/api/data");
        return await response.json();
    } catch (error) {
        console.error("请求失败", error);
    }
}

这里的 await 会将异步操作的拒绝状态重新表现为当前异步函数中的异常,因此可以由 try-catch 捕获。

如果没有 await:

async function loadData() {
    try {
        fetch("/api/data");
    } catch (error) {
        console.error(error);
    }
}

此处 try-catch 通常无法捕获 fetch() 后续发生的 Promise 拒绝,因为异常并不是在当前同步执行阶段抛出的。

五、资源管理与异常安全

异常处理最容易被忽视的问题之一,是异常发生后如何保证资源正确释放。

1. 为什么异常会导致资源泄漏?

假设程序打开文件后发生异常:

def process_file():
    file = open("data.txt", "r")

    content = file.read()

    process_content(content)

    file.close()

如果 process_content() 发生异常,程序可能直接跳过 file.close()。

这会导致文件句柄无法按照预期释放。

类似问题也可能发生在:

  • 数据库连接。
  • 网络 Socket。
  • 文件描述符。
  • 线程锁。
  • 内存资源。
  • 事务对象。

因此,资源管理必须考虑异常路径,而不仅是正常执行路径。

2. finally 与资源释放

一种传统解决方案是使用 finally:

file = None

try:
    file = open("data.txt", "r")
    content = file.read()
    process_content(content)
finally:
    if file is not None:
        file.close()

即使 try 中发生异常,通常也会进入 finally 执行关闭操作。

但对于复杂资源管理,这种方式容易产生重复代码,也容易遗漏清理逻辑。

3. RAII:资源获取即初始化

RAII(Resource Acquisition Is Initialization)是 C++ 中非常重要的资源管理思想。

核心原则:

资源的生命周期与对象的生命周期绑定。

资源在对象构造时获取,在对象析构时释放。

#include <fstream>

void processFile() {
    std::ifstream file("data.txt");

    if (!file.is_open()) {
        throw std::runtime_error("文件打开失败");
    }

    // 处理文件内容
}

当 processFile() 正常返回,或者异常导致栈展开时,局部对象 file 都会被销毁,其析构函数负责关闭文件。

RAII 的优势:

  • 不需要在每个退出路径手动释放资源。
  • 异常发生时仍能执行对象析构。
  • 资源管理与对象生命周期保持一致。
  • 可以降低资源泄漏风险。

RAII 不仅适用于文件,也适用于锁、内存、连接和其他需要明确生命周期的资源。

4. 自动资源管理

不同语言提供了不同的资源管理机制。

语言 资源管理方式 主要机制
C++ RAII 析构函数、智能指针、资源包装对象
Python 上下文管理器 with、__enter__、__exit__
Java try-with-resources AutoCloseable、close()
C# using IDisposable、Dispose()
JavaScript 显式释放及部分资源管理语法 try-finally、资源管理协议

Python 示例:

with open("data.txt", "r") as file:
    content = file.read()
    process_content(content)

Java 示例:

try (FileInputStream input =
         new FileInputStream("data.txt")) {

    // 处理文件内容

} catch (IOException e) {
    e.printStackTrace();
}

这些机制的共同目标是:将资源释放与作用域或对象生命周期绑定,降低异常路径上的资源管理复杂度。

六、异常安全保证