这是可能的，但是不允许直接进行堆分配。堆分配是在运行时执行的。下面是一些示例：

static SOME_INT: i32 = 5;
static SOME_STR: &'static str = "A static string";
static SOME_STRUCT: MyStruct = MyStruct {
    number: 10,
    string: "Some string",
};
static mut db: Option<sqlite::Connection> = None;

fn main() {
    println!("{}", SOME_INT);
    println!("{}", SOME_STR);
    println!("{}", SOME_STRUCT.number);
    println!("{}", SOME_STRUCT.string);

    unsafe {
        db = Some(open_database());
    }
}

struct MyStruct {
    number: i32,
    string: &'static str,
}

只要静态变量是线程局部变量，就可以很容易地使用它们。

缺点是这个对象对于你的程序可能产生的其他线程来说是不可见的。优点是不像真正的全局状态，它是完全安全的，使用起来也不痛苦--真正的全局状态在任何语言中都是一个巨大的痛苦。下面是一个例子：

extern mod sqlite;

use std::cell::RefCell;

thread_local!(static ODB: RefCell<sqlite::database::Database> = RefCell::new(sqlite::open("test.db"));

fn main() {
    ODB.with(|odb_cell| {
        let odb = odb_cell.borrow_mut();
        // code that uses odb goes here
    });
}

这里我们创建一个线程局部静态变量，然后在函数中使用它。注意，它是静态的和不可变的;这意味着它所驻留的地址是不可变的，但是由于RefCell，该值本身将是可变的。
与常规的static不同，在thread-local!(static ...)中可以创建几乎任意的对象，包括那些需要堆分配进行初始化的对象，如Vec、HashMap等。
如果你不能马上初始化这个值，例如，它依赖于用户输入，你可能还必须在那里抛出Option，在这种情况下，访问它会变得有点笨拙：

extern mod sqlite;

use std::cell::RefCell;

thread_local!(static ODB: RefCell<Option<sqlite::database::Database>> = RefCell::New(None));

fn main() {
    ODB.with(|odb_cell| {
        // assumes the value has already been initialized, panics otherwise
        let odb = odb_cell.borrow_mut().as_mut().unwrap();
        // code that uses odb goes here
    });
}

看看const and static section of the Rust book。
您可以使用类似下面的内容：

const N: i32 = 5;

或

static N: i32 = 5;

在全球范围内。
但是这些是不可变的，对于可变性，你可以使用如下的语句：

static mut N: i32 = 5;

然后引用它们如下：

unsafe {
    N += 1;

    println!("N: {}", N);
}

我是Rust的新手，但这个解决方案似乎很有效：

#[macro_use]
extern crate lazy_static;

use std::sync::{Arc, Mutex};

lazy_static! {
    static ref GLOBAL: Arc<Mutex<GlobalType> =
        Arc::new(Mutex::new(GlobalType::new()));
}

另一个解决方案是将横梁通道发送/接收对声明为不可变的全局变量。通道应是有界的，并且只能保存一个元素。初始化全局变量时，将全局示例推入通道。使用全局变量时，弹出通道以获取它，并在使用完它后将其推回。
这两种解决方案都应该提供使用全局变量的安全方法。

如果使用lazy_static宏（如the documentation中所示），则可以为静态变量分配堆：
使用这个宏，静态变量可能需要在运行时执行代码才能被初始化，这包括任何需要堆分配的东西，如向量或哈希Map，以及任何需要计算函数调用的东西。

// Declares a lazily evaluated constant HashMap. The HashMap will be evaluated once and
// stored behind a global static reference.

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

lazy_static! {
    static ref PRIVILEGES: HashMap<&'static str, Vec<&'static str>> = {
        let mut map = HashMap::new();
        map.insert("James", vec!["user", "admin"]);
        map.insert("Jim", vec!["user"]);
        map
    };
}

fn show_access(name: &str) {
    let access = PRIVILEGES.get(name);
    println!("{}: {:?}", name, access);
}

fn main() {
    let access = PRIVILEGES.get("James");
    println!("James: {:?}", access);

    show_access("Jim");
}

我认为这一页涵盖了大部分方面

夜间使用板条箱once_cell或lazy_static或SyncOnceCell。