Initializing a Rust variable passed to async code

问题:

I have a value that cannot be computed at compile time. It needs to be computed before any of the app code runs, and then it will only be read throughout the lifetime of the app. It also needs to be passed around to executors such as tokio and hyper handlers.

How can I create such a value safely, idiomatically and without unneeded performance losses?

• If I create it in main and pass it to hyper, it does not live long enough.
• If I create it with lazy_static!, it only gets computed when it's first accessed. If it can't be computed, then I don't want to run the rest of the application either. I'd rather know I can't connect to the database when I start the application, not when a client makes a request.
• If I make it a static mut, then I can't use it in safe code.

Ideally, I'd like to do something like:

#[tokio::main]
pub async fn main() {
    let db = init_db();

    // This uses a hyper server, passes db around
    // to tokio and hyper handlers, etc.
    run_app(&db);
}

回答1:

You can leak the memory, so that the reference has a 'static lifetime:

#[tokio::main]
pub async fn main() {
    let db = Box::leak(Box::new(init_db())) as &'static _;

    // This uses a hyper server, passes db around
    // to tokio and hyper handlers, etc.
    run_app(db);
}

回答2:

You can wrap the data in a Arc, so your data can be shared and it will live until no references are left for it:

use tokio::prelude::*;
use tokio;
use std::sync::Arc;

async fn init_db() -> Arc<String> {
    Arc::new("Foo".to_string())
}

async fn run_app(data: Arc<String>) {
    for _ in 0..10 {
        println!("{}", data);
    }
}

#[tokio::main]
pub async fn main() {
    let db = init_db().await;

    // This uses a hyper server, passes db around
    // to tokio and hyper handlers, etc.
    run_app(db).await;
}

Playground version

回答3:

If I create it with lazy_static!, it only gets computed when it's first accessed.

There's a specific function to control when a lazy static variable is initialized:

use lazy_static::lazy_static; // 1.4.0

lazy_static! {
    static ref THING: String = String::from("a");
}

#[tokio::main]
pub async fn main() {
    lazy_static::initialize(&THING);
    run_app();
}