深入探索 Unsafe Rust：超越编译器安全保障的超能力-EW帮帮网

一、Unsafe Rust 的背景与动机

Rust 的内存安全性依赖于编译器的严格检查，比如借用检查器和生命周期分析。然而，编译器无法证明所有正确的内存操作，因而在缺乏充分信息时，会拒绝一些合法的代码。此时，开发者可以使用 unsafe 代码块告诉编译器“信任我，我知道我在做什么”。但需要注意，使用 unsafe 并不会关闭其他安全检查，仍然会对引用和其他部分进行检查；它仅允许你执行以下五种 Rust 安全检查之外的操作：

解引用原始指针
调用不安全函数或方法
访问或修改可变静态变量
实现不安全 trait
访问联合体（union）的字段

通过显式标记 unsafe，我们可以将潜在风险的代码区域隔离出来，方便后续审查和维护。

二、Unsafe Rust 的超能力

1. 解引用原始指针

Rust 中原始指针（raw pointers）分为不可变 *const T 和可变 *mut T 两种，它们与常规引用类似，但不受借用规则约束，也没有自动清理机制。我们可以在安全代码中创建原始指针，但必须在 unsafe 代码块中进行解引用。例如：

fn main() {
    let num = 5;

    // 使用原始借用操作符创建不可变和可变原始指针
    let r1 = &num as *const i32;
    let r2 = &num as *const i32;

    unsafe {
        // 在 unsafe 块中解引用原始指针
        println!("r1 is: {}", *r1);
        println!("r2 is: {}", *r2);
    }
}

这种能力让我们可以绕过 Rust 的借用检查规则，但也可能带来空指针、悬挂指针等安全隐患，因此必须格外小心。

2. 调用不安全函数或方法

不安全函数（或方法）的定义和普通函数类似，只是在函数签名前多了一个 unsafe 关键字。这意味着调用这些函数时，必须明确地将其放入 unsafe 代码块中，以表明你已经理解并承担了使用该函数的所有安全责任。例如：

unsafe fn dangerous() {
    // 假设这里有一些操作底层内存的代码
}

fn main() {
    // 必须在 unsafe 块中调用不安全函数
    unsafe {
        dangerous();
    }
}

在一些情况下，我们可以将不安全代码封装在一个安全抽象中，这样使用者便可以在不直接接触不安全代码的情况下享受其功能。例如标准库中的 split_at_mut 就是利用不安全代码实现的安全接口。

3. 访问或修改可变静态变量

Rust 中的全局变量称为静态变量（static），它们拥有固定的内存地址。与常量不同的是，静态变量允许在整个程序运行期间保存状态。访问不可变静态变量是安全的，但对可变静态变量的读写操作则必须放在 unsafe 块中，因为它们可能导致数据竞争或其它内存安全问题。例如：

static mut COUNTER: i32 = 0;

fn increment() {
    unsafe {
        COUNTER += 1;
        println!("COUNTER: {}", COUNTER);
    }
}

fn main() {
    increment();
}

当设计多线程应用时，应尽量避免使用可变静态变量，而选择线程安全的并发原语，如互斥锁（Mutex）或原子类型。

4. 实现不安全 Trait

某些 trait 在其定义上就标记为不安全，原因在于其方法可能有一些编译器无法验证的不变式。实现这类 trait 时，需要使用 unsafe impl 表明你将手动确保所有不变式均被满足。例如：

unsafe trait MyUnsafeTrait {
    // 定义一些不安全的行为或方法
}

struct MyType;

unsafe impl MyUnsafeTrait for MyType {
    // 实现不安全方法，确保安全不变式成立
}

通过这种方式，我们向编译器和其他开发者传达：这里的代码虽然使用了不安全功能，但已经过认真审查，保证不会破坏内存安全。

5. 访问联合体（Union）的字段

联合体（union）与结构体类似，但一次只能存储其中一个字段。由于 Rust 无法在编译时保证当前活跃的字段类型正确，访问联合体字段被认为是不安全的操作，需要在 unsafe 块中进行。例如：

union MyUnion {
    i: i32,
    f: f32,
}

fn main() {
    let u = MyUnion { i: 42 };

    unsafe {
        // 访问联合体字段
        println!("u.i: {}", u.i);
    }
}

联合体主要用于与 C 语言联合体的互操作，或在某些极端性能场景下手动管理内存布局。

三、与外部代码的互操作： extern 关键字

Rust 的 extern 关键字用于定义和调用外部函数，实现跨语言的函数调用接口（FFI）。例如，我们可以通过 extern "C" 声明一个来自 C 标准库的函数 abs：

extern "C" {
    fn abs(input: i32) -> i32;
}

fn main() {
    let num = -3;
    unsafe {
        println!("abs({}) = {}", num, abs(num));
    }
}

如果能够确信某个外部函数在所有情况下都是安全的，我们甚至可以在 extern 块中显式标记为 safe，从而在调用时不再需要 unsafe 块。但这只是对编程者的一种承诺，并不能改变函数本身的不安全特性。

四、使用 Miri 检查不安全代码

由于 Unsafe Rust 绕过了部分编译器的安全检查，为了减少潜在错误，我们可以使用 Miri 这类工具进行动态检查。Miri 能够在运行时捕获未定义行为，例如非法内存访问或数据竞争问题。运行 Miri 需要使用 Rust 的 nightly 版本，并可通过以下命令进行检查：

rustup +nightly component add miri
cargo +nightly miri run

在编写不安全代码时，借助 Miri 进行验证，可以大大提高我们对代码正确性的信心。

五、何时使用 Unsafe Rust

使用 unsafe 并不是鼓励我们随意绕过编译器的安全检查，而是在以下几种情况中：

底层系统编程：直接操作硬件或操作系统接口时，需要绕过某些安全检查。
与其他语言互操作：例如调用 C 语言库，必须使用 FFI 接口。
构建安全抽象：当编译器无法理解某些代码逻辑时，我们可以在内部使用不安全代码，再封装成对外安全的 API。

无论何时使用，都应尽量将 unsafe 块保持最小化，并配以详细的注释（以 SAFETY: 开头），解释为什么该代码是安全的，以及调用者需要遵守的约束。

六、总结

Unsafe Rust 为开发者提供了突破编译器限制的超能力，使我们能进行低级操作、与其他语言交互或构建更高效的抽象。然而，这些能力并非免费的：它们要求开发者对内存和线程安全有更深入的理解，并承担额外的责任来防止出现严重错误。最佳实践包括将不安全代码局部化、提供安全的抽象接口以及使用工具（如 Miri）进行验证。

对于希望深入掌握 Rust 不安全代码的读者，建议参考官方 Rustonomicon 文档，进一步了解如何在不牺牲安全性的前提下发挥 Unsafe Rust 的强大威力。

深入探索 Unsafe Rust：超越编译器安全保障的超能力