Initialize the Model Client Once

One shared client

When several parts of a program need the same model client, a OnceLock can hold the shared value. It starts empty, can be used in a static, and provides thread-safe initialization. Each caller receives a reference to the value once it is ready. Rust’s OnceLock reference describes this behavior.

use std::sync::OnceLock;

struct ModelClient {
    model: &'static str,
}

static CLIENT: OnceLock<ModelClient> = OnceLock::new();

fn model_client() -> &'static ModelClient {
    CLIENT.get_or_init(|| ModelClient {
        model: "configured-model",
    })
}

The small struct stands in for a real client constructor. Put the configuration and construction your application needs inside the closure. Calls to get_or_init may arrive from many threads at once. Rust guarantees that only one initializer runs when that initializer completes without panicking. Later calls use the stored value. This lets callers use the same access function without coordinating construction themselves. The method’s documented guarantee is conditional on the initializer completing.

A panic leaves the slot empty

If the initializer panics, get_or_init propagates the panic to its caller and leaves the cell uninitialized. OnceLock is never poisoned by a panic. If the process continues, a later call can attempt initialization again. The cell does not hold a partly constructed client. These are properties of OnceLock; whether execution continues depends on how the program handles panics. Rust also permits a panic strategy that aborts the process. The Rust book explains both panic strategies.

A returned error has different consequences. If the cell’s type is OnceLock<Result<ModelClient, Error>>, the Result itself is the stored value. By implication, storing Err makes later callers receive that same error. Choose that shape only when retaining the first failure is the behavior you want. get_or_init stores the value returned by its closure.

What to do

Create one OnceLock for a client you intend to share. Put construction behind a function that calls get_or_init, then make callers use that function. Decide what a constructor panic should mean for your application. Decide separately whether an ordinary initialization error should be retained or retried. Keep initialization from calling the same access function again: Rust documents reentrant initialization as an error with an unspecified outcome. See the get_or_init contract.