Rust 生命周期

要点

生命周期标注描述引用之间的约束，不创造存储空间。返回引用必须能追到在调用方使用期间仍有效的数据。

核心概念

概念一：生命周期是”描述”不是”控制”

定义: 生命周期标注（'a 等）不延长也不缩短任何值的存活时间——值的存活由作用域和所有权决定；标注只是把”这些引用必须满足怎样的存活关系”写成编译器可验证的契约。

关键特性:

生命周期的存在目的：防止悬垂引用（引用的数据比引用先销毁）
编译器（借用检查器）在编译期比较所有引用与数据的存活范围，无需运行时开销
标注是泛型参数：fn longest<'a>(...) 声明了一个叫 'a 的抽象存活范围，调用时由实参具体化

使用场景:

函数返回引用且来源可能有歧义（多个引用输入）
结构体持有引用（成员的存活不能超过被引用数据）
泛型约束 T: 'a（T 不能内含短命引用）

概念二：三条生命周期省略（elision）规则

定义: 编译器按固定规则为常见签名自动推断标注，规则确定时无需手写。

关键特性:

规则一：每个作为输入的引用参数各获得独立的生命周期（fn f(x: &str) → x: &'1 str）
规则二：若只有一个输入生命周期，它被赋给所有输出引用（fn first_word(s: &str) -> &str 无需标注）
规则三：若参数中有 &self / &mut self，self 的生命周期被赋给所有输出引用（方法返回 &str 通常无需标注）

使用场景:

规则覆盖不了时（两个引用输入 + 一个引用输出），编译器报 E0106 “missing lifetime specifier”，此时才手写标注

概念三：`'static` 与结构体生命周期

定义: 'static 表示引用在程序整个运行期间有效；结构体上的 <'a> 表示”该实例的存活不能超过 'a 所指的数据”。

关键特性:

所有字符串字面量都是 &'static str（编译进二进制）
T: 'static 约束常见于 thread::spawn 与 tokio::spawn 这类 spawn 出的线程/任务——被移入其中执行的数据必须拥有（或 'static），不能依赖别人的栈帧；普通地在 async 函数里跨 .await 持有借用则是合法的，不要求 'static
Box::leak 可把堆数据受控转换为 &'static（如全局配置表），代价是这块内存不再归还

使用场景:

结构体解析一段文本并保存其切片（如日志解析器的 LogLine<'a>）
需要程序级单例数据时用 Box::leak 或 LazyLock

实践指南

步骤一：识别”省略规则够用”的签名

目标: 避免”见到引用就加 'a“的过度标注。

操作指南:

数一数函数签名里有几个引用输入、有没有引用输出
只有一个引用输入、或有 &self → 直接写，编译器按规则二/三推断
两个引用输入 + 引用输出 → 必须手写 'a（并想清楚：返回值到底跟谁同生共死？）

验证方法: 先不加标注编译，报 E0106 再补；补上后读一遍签名自问”‘a’ 的含义说得通吗”。

步骤二：给”返回两者中较长者”补标注

目标: 体验生命周期错误信息的读法。

操作指南:

写 fn longest(a: &str, b: &str) -> &str，编译报 E0106
按编译器建议改为 fn longest<'a>(a: &'a str, b: &'a str) -> &'a str
造一个”短命实参 + 长命 result”的用例，观察 E0597（borrowed value does not live long enough）

验证方法: 取消下方示例二注释行，确认编译器在 println!("{result}") 处拦截悬垂。

步骤三：把生命周期搬到结构体上

目标: 掌握 struct Excerpt<'a> 与 impl<'a> 的固定写法。

操作指南:

结构体持有 &'a str 成员时，在结构体名后声明 <'a>
impl 块同样声明 impl<'a> Excerpt<'a>
记住语义：不是 Excerpt 活得久，而是 Excerpt 活不过它引用的数据

验证方法: 尝试让 Excerpt 的数据源提前离开作用域，确认编译器拦截。

代码示例

示例一：省略规则生效的典型场景

// 块1：生命周期省略规则
fn main() {
    let novel = String::from("call me ishmael some years ago");
    let first = first_word(&novel); // 省略规则自动生效，无需标注
    println!("{first}");
}

// 单引用输入 => 输出生命周期自动跟随输入（省略规则第 2 条）
fn first_word(s: &str) -> &str {
    s.split_whitespace().next().unwrap_or("")
}

关键点解析:

s: &str 是唯一引用输入，规则二把它的生命周期赋给返回值——签名无需任何标注
返回的是 novel 的切片，novel 活着，first 就合法

示例二：显式 `'a` 与悬垂拦截

// 块2：显式标注 'a
fn main() {
    let s1 = String::from("long string is long");
    let result;
    {
        let s2 = String::from("xyz");
        result = longest(s1.as_str(), s2.as_str());
        println!("{result}"); // OK：s2 在 result 使用期间仍存活
    }
    // println!("{result}"); // 编译错误：s2 已销毁，result 可能悬垂
}

// 'a 是两个输入与输出共同遵守的约束：
// 返回值的存活时间不得超过 a、b 中较短的那个
fn longest<'a>(a: &'a str, b: &'a str) -> &'a str {
    if a.len() > b.len() { a } else { b }
}

关键点解析:

'a 不要求 a、b 生命周期完全相同，只要求两者的交集覆盖返回值的使用期
在内层作用域内 result 合法；出了作用域编译器用 E0597 拒绝——这正是悬垂防护的现场演示

示例三：持有引用的结构体

// 块3：持有引用的结构体
fn main() {
    let novel = String::from("很久很久以前有一座山。山里有一座庙。");
    let first_sentence = novel.split('。').next().unwrap_or("");
    let excerpt = Excerpt { part: first_sentence };
    excerpt.announce("摘录如下");
    println!("正文：{}", excerpt.part);
}

// 持有引用的结构体必须标注生命周期：
// Excerpt 实例的存活时间不得超过 part 引用的数据
struct Excerpt<'a> {
    part: &'a str,
}

impl<'a> Excerpt<'a> {
    // 方法返回 &str 时省略规则第 3 条生效：输出跟随 &self
    fn announce(&self, msg: &str) -> &str {
        println!("提示：{msg}");
        self.part
    }
}

关键点解析:

announce 返回 &str 时规则三（&self 优先）生效，无需再写 'a
Excerpt 是”零复制”设计：只存指针不复制文本，代价是必须与数据源绑定生命周期

示例四：`'static` 的三个来源

// 块4：'static 生命周期
fn main() {
    // 字符串字面量的类型是 &'static str：从程序启动活到结束
    let s: &'static str = "我活在程序的整个生命周期";
    println!("{s}");

    // Box::leak：受控地把堆数据"泄漏"成 'static 引用
    let leaked: &'static str =
        Box::leak(String::from("泄漏到 static").into_boxed_str());
    println!("{leaked}");

    // 泛型约束：T 必须活得和 'static 一样久（拥有数据，而非借用）
    fn describe<T: std::fmt::Display + 'static>(item: T) -> String {
        format!("{item}")
    }
    println!("{}", describe(s));
    println!("{}", describe(String::from("拥有的 String 天然满足 'static")));
}

关键点解析:

T: 'static 是”最严格”的约束，因为拥有所有权的类型（String、Vec<i32>）天然满足
Box::leak 适合程序级常量表；普通业务代码出现 'static 引用前先想想是不是该直接拥有数据

示例五：泛型 + 生命周期组合（含测试）

// 块5：泛型 + 生命周期组合 + 测试
fn longest_of_all<'a>(items: &'a [&'a str]) -> Option<&'a str> {
    items.iter().copied().max_by_key(|s| s.len())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn 取最长词() {
        let words = vec!["hi", "rust", "collection"];
        assert_eq!(longest_of_all(&words), Some("collection"));
    }

    #[test]
    fn 空切片返回_none() {
        let empty: Vec<&str> = Vec::new();
        assert_eq!(longest_of_all(&empty), None);
    }
}

关键点解析:

签名读作：输入是”字符串切片数组”的借用，返回其中某一切片，返回值存活不超过数组与其元素
Option<&str> 把”空输入”显式化——生命周期与 Option 的组合是标准库高频形态

最佳实践

生命周期标注描述引用之间必须满足的关系，不会延长被引用数据的存在时间。函数返回局部 String 的引用无论怎样改标注都无效，应返回所有权或让调用方提供活得足够久的存储。

先利用省略规则，确实无法表达关联时再标注；不以未经统计的百分比判断是否需要。借用型结构体适合视图或解析结果，拥有型更独立但可能复制。区分 &’static T 与 T: ‘static：后者不要求值实际活到进程结束，而是限制其中借用。

可复现验收：借用结果与拥有结果的分界

生命周期标注只能让返回的借用与输入借用建立关系；它不能让函数把局部变量的借用带出函数。需要在函数内部构造并返回新文本时，返回拥有所有权的 String。下面的程序同时演示这两条规则：longest 返回输入之一的切片，owned_label 返回自己的 String。

fn longest<'a>(left: &'a str, right: &'a str) -> &'a str {
    if left.len() >= right.len() { left } else { right }
}

fn owned_label() -> String {
    let local = String::from("owned");
    local
}

fn main() {
    let left = String::from("pear");
    let right = String::from("banana");
    println!("borrowed={}", longest(&left, &right));
    println!("owned={}", owned_label());
}

预期输出：

borrowed=banana
owned=owned

下面的反例必须拒绝编译。local.as_str() 指向函数结束时就会被释放的 String；把它伪装成任意生命周期的 &str 会制造悬垂引用，因此 Rust 报 E0515。修复方式不是强行补生命周期，而是像上例一样返回 String，或让调用者提供并持有数据。

fn invalid<'a>() -> &'a str {
    let local = String::from("temporary");
    local.as_str()
}

fn main() {
    println!("{}", invalid());
}

常见问题

Q1: 生命周期标注到底检查什么？会影响性能吗？

A: 只在编译期做区间比较——”引用的使用范围是否落在数据存活范围内”。零运行时开销，这就是”无 GC 但内存安全”的实现机制。更多借用检查细节见 Rust 所有权与借用。

Q2: 为什么两个引用输入必须手写 `'a`？

A: 编译器无法替你做业务决策：返回值跟 a 还是 b 同生共死？规则一给两个输入各分配了独立生命周期，输出引用无法归属，E0106 就是”请明示”的信号。写出 <'a>(a: &'a str, b: &'a str) -> &'a str 的瞬间，你声明了”取交集”这一业务语义。

Q3: 报错建议我加 `+ 'static`，一定要照做吗？

A: 先想数据从哪来。若函数要 spawn 线程或把值装进 async 任务，被移动的值确实不能借用当前栈帧——此时 T: 'static（或直接拥有数据）是正解。但若是误报（比如你只想临时借用），考虑把作用域保持在同一线程内，或用 Arc 共享（见 Rust 智能指针）。

练习与实践

练习一：省略规则判读

目标: 巩固三条规则的适用判断。

任务要求:

判断以下签名是否需要手写标注：fn last(s: &str) -> &str、fn max(a: &i32, b: &i32) -> &i32、fn echo(&self) -> &str
为需要标注的那个补上 'a 并解释语义
编译验证你的判断

评估标准: 只给 max 补了标注且能说清”两个引用输入、无 &self“的原因。

练习二：零复制解析器

目标: 综合结构体生命周期。

挑战任务:

实现 struct LogLine<'a>，从 "2026-09-16 INFO boot" 形式的日志行切片出 level 与 message 两个 &'a str 字段
为解析函数写单元测试，覆盖空行与格式错误（返回 Result 或 Option）

提示: splitn + str::trim 产出的都是源字符串的切片，天然满足 'a。

前置知识

所有权与借用——生命周期标注只是既有引用规则的显式化
结构体、枚举与模式匹配与 Trait 与泛型——T: 'a 这类约束建立在它们之上

后续学习

生命周期标注 → Rust 智能指针摆脱借用束缚、Rust 并发与异步的 Future 自引用结构

一	二	三	四	五	六	日
						1
2	3	4	5	6	7	8
9	10	11	12	13	14	15
16	17	18	19	20	21	22
23	24	25	26	27	28

归档

近期文章

要点

核心概念

概念一：生命周期是”描述”不是”控制”

概念二：三条生命周期省略（elision）规则

概念三：`'static` 与结构体生命周期

实践指南

步骤一：识别”省略规则够用”的签名

步骤二：给”返回两者中较长者”补标注

步骤三：把生命周期搬到结构体上

代码示例

示例一：省略规则生效的典型场景

示例二：显式 `'a` 与悬垂拦截

示例三：持有引用的结构体

示例四：`'static` 的三个来源

示例五：泛型 + 生命周期组合（含测试）

最佳实践

可复现验收：借用结果与拥有结果的分界

常见问题

Q1: 生命周期标注到底检查什么？会影响性能吗？

Q2: 为什么两个引用输入必须手写 `'a`？

Q3: 报错建议我加 `+ 'static`，一定要照做吗？

相关资源

延伸阅读

工具资源

练习与实践

练习一：省略规则判读

练习二：零复制解析器

前置知识

后续学习

发送评论编辑评论

要点

核心概念

概念一：生命周期是”描述”不是”控制”

概念二：三条生命周期省略（elision）规则

概念三：'static 与结构体生命周期

实践指南

步骤一：识别”省略规则够用”的签名

步骤二：给”返回两者中较长者”补标注

步骤三：把生命周期搬到结构体上

代码示例

示例一：省略规则生效的典型场景

示例二：显式 'a 与悬垂拦截

示例三：持有引用的结构体

示例四：'static 的三个来源

示例五：泛型 + 生命周期组合（含测试）

最佳实践

可复现验收：借用结果与拥有结果的分界

常见问题

Q1: 生命周期标注到底检查什么？会影响性能吗？

Q2: 为什么两个引用输入必须手写 'a？

Q3: 报错建议我加 + 'static，一定要照做吗？

相关资源

延伸阅读

工具资源

练习与实践

练习一：省略规则判读

练习二：零复制解析器

前置知识

后续学习

发送评论 编辑评论

概念三：`'static` 与结构体生命周期

示例二：显式 `'a` 与悬垂拦截

示例四：`'static` 的三个来源

Q2: 为什么两个引用输入必须手写 `'a`？

Q3: 报错建议我加 `+ 'static`，一定要照做吗？

发送评论编辑评论