Rust 語言教學 – 生命週期

單元：靜態生命週期（`'static`）

簡介

在 Rust 中，**生命週期（lifetime）**是保證記憶體安全的核心概念。大多數程式在執行時會產生許多暫時的引用，而編譯器必須確保這些引用在使用期間仍然有效。
'static 是所有生命週期中最長的一個，它代表「程式執行期間都有效」的資料。了解 'static 的行為與限制，對於編寫全域常數、字串常量、跨執行緒傳遞資料，甚至是與外部 C 函式介面（FFI）互動，都相當重要。

本篇文章將以 淺顯易懂 的方式說明 'static 的意義、常見用法與陷阱，並提供 實務範例，協助從初學者到中級開發者快速掌握這個概念。

核心概念

1. `'static` 的定義

'static 不是「變數一定要在程式最上層」的代名詞，而是指 資料的生命週期與整個程式相同。
兩種情況會得到 'static 生命週期：
1. 編譯期常量（如字串常量、數值常量）直接嵌入二進位檔。
2. 堆配置的資料在程式結束前不會被釋放（例如使用 Box::leak、lazy_static!、once_cell 等方式）。

2. 為什麼字串常量自帶 `'static`

let s: &'static str = "Hello, world!";

"Hello, world!" 在編譯時就被寫入執行檔的只讀段（read‑only segment），因此它的位址在程式執行期間永遠不會變動。
編譯器自動把這類字面值（string literal）視為 &'static str，不需要額外的 static 關鍵字。

3. `static` 與 `const` 的差異

	`static`	`const`
儲存位置	真正的全域變數，位於記憶體的固定位置	直接在編譯期內聯（inline）到使用處
可變性	需要加上 `mut` 才能變更（`static mut`）	永遠不可變
生命週期	`'static`（整個程式期間）	同樣是 `'static`，但不佔用記憶體位址

註：static mut 會產生 資料競爭（data race），除非在 unsafe 區塊內使用，且必須自行保證同步安全。

4. `'static` 與泛型生命週期

在函式或型別參數上使用 'static，可以限制傳入的引用必須在程式結束前仍然有效：

fn store_global<T: 'static>(value: T) {
    // 把 value 放進全域容器（例如 lazy_static!）
}

此時編譯器會檢查 T 是否包含任何非 'static 的引用，若有則編譯失敗。

5. 常見的 `'static` 取得方式

取得方式	說明	範例
字串常量	編譯期嵌入	`"abc"`
`Box::leak`	把 `Box<T>` 轉成 `&'static T`，永不釋放	`Box::leak(Box::new(42))`
`lazy_static!` / `once_cell::sync::Lazy`	延遲初始化的全域變數	`static REF: Lazy = Lazy::new(
`static` 變數	手動宣告全域變數	`static CONFIG: &str = "prod";`
FFI 介面	C 語言提供的全域字串	`extern "C" { static EXTERN_STR: *const u8; }`

程式碼範例

範例 1：最簡單的字串常量 (`'static str`)

fn greet(name: &str) {
    println!("Hello, {}!", name);
}

fn main() {
    // 直接使用字面值，它的類型是 &'static str
    let hello: &'static str = "Hello, Rust!";
    greet(hello); // 安全無需任何額外生命週期標註
}

說明：hello 會在程式整個執行期間保持有效，即使 greet 把它傳給其他函式也不會產生懸掛指標。

範例 2：使用 `Box::leak` 產生 `'static` 引用

fn main() {
    // 把一個 heap 上的 i32 變成 &'static i32
    let leaked: &'static i32 = Box::leak(Box::new(100));

    // 之後可以安全地在任何地方使用
    println!("leaked value = {}", leaked);
}

注意：Box::leak 會把記憶體「泄漏」到程式結束，這在嵌入式或長時間執行的服務端程式中應慎用，除非真的需要永久保存資料。

範例 3：`lazy_static!` 建立全域資料

use lazy_static::lazy_static;
use std::collections::HashMap;

lazy_static! {
    // 這個 HashMap 只會在第一次被存取時初始化
    static ref CONFIG: HashMap<&'static str, i32> = {
        let mut m = HashMap::new();
        m.insert("max_connections", 100);
        m.insert("timeout_sec", 30);
        m
    };
}

fn get_config(key: &'static str) -> Option<i32> {
    CONFIG.get(key).cloned()
}

fn main() {
    println!("max_connections = {:?}", get_config("max_connections"));
}

說明：lazy_static! 產生的 CONFIG 本身的類型是 &'static HashMap<...>，因此在任何執行緒中都可以安全共享（只要內部型別本身是 Sync）。

範例 4：跨執行緒傳遞 `'static` 閉包

use std::thread;

fn spawn_task<F>(task: F)
where
    F: FnOnce() + Send + 'static,
{
    thread::spawn(task);
}

fn main() {
    let msg: &'static str = "從主執行緒傳遞的訊息";

    spawn_task(move || {
        // 這裡的閉包捕獲了 msg，必須是 'static
        println!("{}", msg);
    });

    // 主執行緒稍作等待，避免程式過早結束
    thread::sleep(std::time::Duration::from_millis(50));
}

重點：thread::spawn 要求傳入的閉包必須是 'static，因為執行緒可能在原始呼叫者結束後仍然存活。

範例 5：FFI 中的 `'static` 字串

extern "C" {
    // 假設這是一個由 C 程式提供的全域字串
    static EXTERN_MESSAGE: *const u8;
}

fn main() {
    unsafe {
        // 把 C 的字串轉成 Rust 的 &str（必須保證它是 UTF‑8 且長度正確）
        let c_str = std::ffi::CStr::from_ptr(EXTERN_MESSAGE as *const i8);
        let rust_str = c_str.to_str().expect("Invalid UTF-8");
        println!("C 提供的訊息: {}", rust_str);
    }
}

說明：外部提供的全域指標在 Rust 中會被視為 'static，因為它的生命週期由外部程式決定，通常是整個執行期間。

常見陷阱與最佳實踐

陷阱	說明	解決方式
誤以為 `&'static str` 必須使用 `static` 宣告	事實上字面值自動是 `'static`，不需要額外 `static` 關鍵字。	直接使用字串常量，或使用 `const` 產生編譯期常數。
把大量資料放進 `static`，導致二進位過大	`static` 變數會在編譯時就被寫入執行檔。	使用 `lazy_static!` / `once_cell` 延遲載入，或使用 `Box::leak` 動態分配。
在多執行緒環境下直接使用 `static mut`	會產生未同步的資料競爭，編譯器只能在 `unsafe` 中允許。	改用 `static` + `Mutex` / `RwLock`，或使用原子類型（`AtomicUsize`）。
把本地變數的引用傳給需要 `'static` 的 API	編譯錯誤：引用的生命週期過短。	使用 `Box::leak`、`Arc::new`（搭配 `move`）或改寫 API 讓其接受非 `'static` 的參數。
忘記釋放 `Box::leak` 的記憶體	長時間服務會造成記憶體泄漏。	僅在確定資料真的需要永久保存時使用，或改用 `once_cell::sync::Lazy`。

最佳實踐

盡量使用 lazy_static! / once_cell：它們提供安全的延遲初始化與自動釋放（在程式結束時）。
對跨執行緒的全域資料加上同步原語（Mutex、RwLock、原子類型），避免未定義行為。
在函式簽名中使用 'static 時，先思考是否真的需要：若只是想在 thread::spawn 中使用，考慮把資料包成 Arc<T> 再傳遞。
對於 FFI，務必確認外部提供的指標在 Rust 中的生命週期，必要時自行包裝成 static 或 Arc。

實際應用場景

全域設定檔
使用 once_cell::sync::Lazy 或 lazy_static! 讀取設定檔（JSON、YAML），在程式啟動時載入，之後所有模組都能以 &'static Config 讀取，避免重複 I/O。
國際化字串（i18n）
所有語系字串可放在編譯期的 static 陣列或 phf（完美雜湊）表格中，取得時返回 &'static str，保證不會因為語系切換而產生懸掛指標。
跨執行緒任務排程
tokio::spawn、std::thread::spawn 需要 'static 閉包。把需要的資料包成 Arc<T>，或使用 Box::leak 產生永久引用，以符合 'static 要求。
嵌入式系統的常數表
在資源受限的 MCU 上，將查表資料宣告為 static（或 const）可以直接放在 Flash，節省 RAM。
與 C/C++ 函式庫的互動
C 函式庫常提供全域字串或結構體指標，Rust 端使用 extern "C" 宣告，這些指標自然是 'static，只要確保不在 Rust 中自行釋放即可。

總結

'static 代表 程式執行期間都有效 的生命週期，是所有其他生命週期的最上層。
字串常量、static 變數、Box::leak、lazy_static!/once_cell 都是取得 'static 引用的常見手段。
使用 'static 時要特別留意 記憶體泄漏、全域可變性（static mut）以及 跨執行緒安全。
在實務開發中，全域設定、國際化字串、跨執行緒任務、FFI 等場景最常需要 'static。
透過 適當的同步原語（Mutex、Arc）與 延遲初始化工具（lazy_static!、once_cell），可以安全、有效率地利用 'static，同時保持程式的可維護性與記憶體安全。

掌握 'static 的概念與正確使用方式，將讓你的 Rust 程式在 安全性、效能與可擴充性 上都更上一層樓。祝你寫程式快樂，持續探索 Rust 的魅力！

Rust 語言教學 – 生命週期

單元：靜態生命週期（'static）

簡介

核心概念

1. 'static 的定義

2. 為什麼字串常量自帶 'static

3. static 與 const 的差異

4. 'static 與泛型生命週期

5. 常見的 'static 取得方式