静态变量 static ​

什么是静态变量 ​

静态变量用 static 关键字声明,它在程序的整个运行期间都存在,有固定的内存地址。和 const 常量不同,静态变量不会被内联到使用处,而是在内存中只保存一份,所有使用它的地方都引用同一个内存位置。

静态变量和 const 一样默认是不可变的,也要求显式标注类型,值也必须是编译期可确定的常量表达式。命名规范同样是全大写字母加下划线。

rust
// 声明一个静态变量
// 和 const 的区别是:static 在内存中有固定地址,只存一份
static APP_NAME: &str = "MyRustApp";
static VERSION: u32 = 1;
static MAX_CONNECTIONS: usize = 100;

fn main() {
    println!("应用名称:{}", APP_NAME);
    println!("版本号:{}", VERSION);
    println!("最大连接数:{}", MAX_CONNECTIONS);

    // 静态变量有固定的内存地址,可以取引用
    let name_ref: &str = APP_NAME;
    println!("通过引用访问:{}", name_ref);
}

static 和 const 的核心区别 ​

初学者经常搞混 static 和 const,它们表面上很像,但在内存模型上有本质区别。

对比项conststatic
内存位置无固定地址,值被内联到每个使用处有固定地址,程序全局只存一份
可以取引用不能直接取地址可以,引用的生命周期是 'static
可变性永远不可变默认不可变,可以用 static mut(unsafe)
初始化时机编译时内联程序启动时初始化
适用场景编译期常量、配置值全局共享数据、FFI 交互、需要固定地址的场景
类型限制必须实现 Sized必须实现 Sync(因为可能被多线程访问)
rust
const CONST_VAL: i32 = 42;
static STATIC_VAL: i32 = 42;

fn main() {
    // const 在每个使用处内联,两次取地址可能不同
    // (实际上 const 不能直接取地址)

    // static 有固定地址,可以取引用
    let r: &i32 = &STATIC_VAL;
    println!("静态变量的引用:{}", r);
    println!("静态变量的地址:{:p}", r);

    // 对 const 取引用时,编译器会创建一个临时变量
    let r2: &i32 = &CONST_VAL;
    println!("const 值:{}", r2);
}

static 变量的生命周期 ​

静态变量的生命周期是 'static,意味着它从程序开始运行到结束一直存在。这也是为什么静态变量的引用类型是 &'static T。

rust
static GREETING: &str = "Hello, World!";

// 返回值的生命周期是 'static,因为 GREETING 永远存在
fn get_greeting() -> &'static str {
    GREETING
}

// 字符串字面量本身也是 'static 的
fn get_literal() -> &'static str {
    "这也是 'static 生命周期"
}

fn main() {
    let g = get_greeting();
    let l = get_literal();
    println!("{}", g);
    println!("{}", l);
}

static 变量的类型要求 ​

静态变量的类型必须实现 Sync trait,因为静态变量可以被多个线程同时访问。大多数基本类型和不可变引用都实现了 Sync,所以实际使用中这个限制很少成为问题。

rust
// 这些类型都实现了 Sync,可以用作 static 变量
static NUM: i32 = 42;
static FLOAT: f64 = 3.14;
static FLAG: bool = true;
static TEXT: &str = "hello";
static ARRAY: [i32; 3] = [1, 2, 3];

// 以下类型没有实现 Sync,不能用作 static 变量
// static BAD: Rc<i32> = Rc::new(42);  // Rc 不是 Sync 的
// static BAD2: Cell<i32> = Cell::new(42);  // Cell 不是 Sync 的

fn main() {
    println!("{}, {}, {}, {}, {:?}", NUM, FLOAT, FLAG, TEXT, ARRAY);
}

基本示例 ​

静态变量常见的使用场景——全局配置和字符串常量表:

rust
// 应用程序配置
static DB_HOST: &str = "localhost";
static DB_PORT: u16 = 5432;
static DB_NAME: &str = "myapp";

// 错误码和消息映射
static ERROR_MESSAGES: [&str; 4] = [
    "操作成功",           // 0
    "参数错误",           // 1
    "权限不足",           // 2
    "资源不存在",         // 3
];

fn get_error_message(code: usize) -> &'static str {
    // 如果 code 超出范围,返回默认消息
    if code < ERROR_MESSAGES.len() {
        ERROR_MESSAGES[code]
    } else {
        "未知错误"
    }
}

fn get_db_url() -> String {
    // 拼接数据库连接字符串
    format!("postgres://{}:{}/{}", DB_HOST, DB_PORT, DB_NAME)
}

fn main() {
    println!("数据库连接:{}", get_db_url());

    for code in 0..5 {
        println!("错误码 {} -> {}", code, get_error_message(code));
    }
}

常见问题 ​

问题一:什么时候该用 static 而不是 const?

大多数情况下用 const 就够了。以下场景需要用 static:

  • 需要取变量的内存地址(比如传给 C 函数)
  • 值很大(比如一个大数组),不希望在每个使用处都复制一份
  • 需要全局可变状态(static mut,不推荐,详见下一节)
  • 需要在运行时初始化的全局变量(配合 OnceLock 等)

问题二:static 变量可以在函数内部声明吗?

可以,但它的生命周期仍然是整个程序运行期间,不受函数作用域限制。

rust
fn counter() -> i32 {
    // 函数内部的 static 变量,但它的生命周期是 'static
    // 注意:不可变的 static 在函数内没什么特别意义
    // 真正有用的是 static mut(但需要 unsafe)
    static START_VALUE: i32 = 100;
    START_VALUE
}

fn main() {
    println!("{}", counter());  // 100
    println!("{}", counter());  // 100,每次调用返回同一个值
}

问题三:为什么 static 变量要求类型实现 Sync?

因为 Rust 的线程安全模型。静态变量在整个程序中只有一份,任何线程都可以访问它。如果类型不是 Sync 的(比如 Rc),多线程同时访问可能导致数据竞争。要求 Sync 是编译器在保护你。

问题四:能在 static 中使用 String、Vec 等堆分配类型吗?

直接不行,因为 String::from() 和 Vec::new() 目前不是 const fn(在稳定版中)。但你可以用 &str 代替 String,用固定大小数组 [T; N] 代替 Vec。如果确实需要运行时初始化的全局变量,可以用标准库的 OnceLock 或第三方的 lazy_static / once_cell。

适用场景 ​

  • 全局字符串常量表:错误消息、配置项名称等,用 static 保证只存一份
  • 与 C 代码交互(FFI):C 函数可能需要一个固定地址的全局变量
  • 大型只读数据:嵌入到二进制文件中的大数组或查找表
  • 单例模式的基础:配合 OnceLock 实现运行时初始化的全局单例
  • 需要 'static 生命周期引用的场景:某些 API 要求传入 'static 引用

注意事项 ​

  • 优先使用 const,只在需要固定内存地址或大型数据时才用 static
  • 不可变的 static 是线程安全的,可以放心在多线程环境中使用
  • static mut 是不安全的,任何访问都需要 unsafe 块,应尽量避免使用(详见下一节)
  • 静态变量的初始化顺序不受控制(多个 static 之间),不要让它们产生初始化顺序依赖
  • 静态变量在程序结束时不会调用 Drop(它的生命周期是"整个程序",没有"离开作用域"的概念)
  • 命名规范是 SCREAMING_SNAKE_CASE,和 const 一样

总结 ​

static 用于声明具有 'static 生命周期的全局变量,在程序运行期间只存一份,有固定的内存地址。和 const 的主要区别在于 static 不会被内联,而是所有使用处都引用同一个内存位置。默认情况下 static 变量是不可变的,类型必须实现 Sync trait。在大多数场景下 const 就能满足需求,static 更适合需要固定内存地址、大型只读数据、FFI 交互等特殊场景。如果需要全局可变状态,不要用 static mut,而应该用 OnceLock、Mutex 等安全的同步原语。