《Rust编程实战》7.1 Unsafe场景分析

7.1 Unsafe 场景分析

Rust 提供了一套严格的安全保障，依赖编译器的所有权系统、借用检查器以及生命周期约束，确保内存安全。然而，在某些场景中，使用 Unsafe Rust 是不可避免的，Unsafe 允许开发者绕过编译器的检查，手动保证代码的正确性。

7.1.1 什么是 Unsafe Rust

Unsafe Rust 是一种允许绕过 Rust 安全性检查的模式，它解锁了以下操作：

1. 解引用裸指针（*const T 和 *mut T）
   允许直接操作指针而不经过借用检查。

2. 调用不安全的函数或方法
   包括 FFI（外部函数接口）调用和标记为 unsafe 的 Rust 函数。

3. 访问或修改 static mut 变量
   使用全局可变状态，存在数据竞争的风险。

4. 实现不安全的 trait
   比如某些涉及底层操作的系统接口。

5. 调用 unsafe 块中的内在函数
   例如直接调用汇编指令或底层操作。

这些功能为开发者提供了强大的能力，但也要求更加谨慎的安全保证。

7.1.2 常见的 Unsafe 使用场景

以下是一些典型的 Unsafe 使用场景，以及为什么需要绕过安全检查。

1. 高性能数据结构

Unsafe 经常用于构建高性能的数据结构，例如链表、哈希表或自定义分配器。这些场景需要手动管理内存，同时绕过借用检查器以提高性能。

示例：双向链表

在实现双向链表时，Rust 的所有权系统会限制节点的双向链接，因为一个节点需要同时拥有父节点和子节点的引用。在这种情况下，可以通过裸指针（*mut T）绕过借用规则。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

use std::ptr;

struct Node<T> {
    value: T,
    prev: *mut Node<T>,
    next: *mut Node<T>,
}

impl<T> Node<T> {
    fn new(value: T) -> Self {
        Node {
            value,
            prev: ptr::null_mut(),
            next: ptr::null_mut(),
        }
    }
}

通过裸指针构建双向链表时，需要特别注意避免解引用空指针或发生数据竞争。

2. 外部函数接口（FFI）

与 C 或其他语言交互时，必须使用 Unsafe 调用外部函数。这是因为 Rust 无法验证外部代码的内存安全性。

示例：调用 C 函数

1
2
3
4
5
6
7

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

fn call_abs(x: i32) -> i32 {
    unsafe { abs(x) }
}

在这种场景中，开发者需要确保外部函数的行为符合预期，例如输入参数和返回值的约定。

3. 手动内存分配

在某些高性能场景中，开发者需要手动分配和释放内存，而不是依赖 Rust 的内存管理机制。这种操作需要使用 Unsafe。

示例：使用 std::alloc 手动分配内存

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

use std::alloc::{alloc, dealloc, Layout};

fn manual_allocation() {
    let layout = Layout::new::<u32>();
    unsafe {
        let ptr = alloc(layout) as *mut u32;
        if ptr.is_null() {
            panic!("Memory allocation failed");
        }
        *ptr = 42; // 写入值
        println!("Value: {}", *ptr);
        dealloc(ptr as *mut u8, layout); // 释放内存
    }
}

在手动分配内存时，开发者需要确保分配与释放匹配，避免内存泄漏或未定义行为。

4. 实现底层系统功能

Unsafe 用于编写底层代码，例如操作系统内核、驱动程序或嵌入式开发。这类代码通常直接操作硬件或内存。

示例：访问特定内存地址

1
2
3
4
5

const GPIO_BASE: usize = 0x3F200000;

fn read_gpio() -> u32 {
    unsafe { *(GPIO_BASE as *const u32) }
}

这种场景下，开发者需要清楚了解目标硬件的内存布局，避免非法访问。

5. 取消引用的生命周期约束

在某些复杂的借用场景中，使用 Unsafe 可以打破生命周期约束，例如实现自定义的智能指针。

示例：实现自定义智能指针

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

struct MyBox<T> {
    ptr: *mut T,
}

impl<T> MyBox<T> {
    fn new(value: T) -> Self {
        let boxed = Box::new(value);
        MyBox {
            ptr: Box::into_raw(boxed),
        }
    }

    fn get(&self) -> &T {
        unsafe { &*self.ptr }
    }
}

这里使用了 Box::into_raw 将 Box 的所有权转移为裸指针，同时通过 Unsafe 实现解引用。

7.1.3 Unsafe 的风险

虽然 Unsafe 提供了绕过检查的能力，但也带来了以下风险：

1. 数据竞争
   多线程环境中，未妥善保护的可变数据可能引发数据竞争。

2. 未定义行为
   例如解引用空指针、悬空指针或违反内存对齐规则。

3. 内存泄漏
   手动分配的内存未正确释放可能导致内存泄漏。

4. 代码复杂度
   使用 Unsafe 的代码难以阅读和维护，同时难以推导其安全性。

7.1.4 如何确保 Unsafe 的安全性

在使用 Unsafe 时，开发者需要手动保证代码的安全性，可参考以下原则：

1. 封装 Unsafe
   将 Unsafe 代码封装在安全的接口中，避免外部代码直接访问不安全部分。

2. 文档说明
   明确记录 Unsafe 的用途和安全性假设。

3. 测试覆盖
   编写详尽的单元测试和集成测试，验证 Unsafe 代码的行为。

4. 审查与评估
   定期审查 Unsafe 代码，确保符合设计预期。

总结

Unsafe 是 Rust 中不可或缺的部分，为高性能数据结构、底层系统功能以及 FFI 提供了必要的灵活性。尽管 Unsafe 绕过了编译器的安全保障，但通过合理的设计和审慎的使用，可以在保持性能的同时，最大程度确保代码的可靠性。

• Rust
• Rust Programming in Action
• Rust编程实战
• Rust Tutors