Alternative to `static mut` and unsafe while managing global application state

Question

Background

I have been learning rust recently and my most recent project involves setting a global APP_STATE that can then be accessed throughout the app. There are a few other globals as well.

Note: These variables pretty much need to be globals, otherwise I will have to pass them as arguments into every function and trait I have - which is not very elegant.

The Problem

The aforementioned globals are mutable, i.e they are represented like the following:

pub Struct AppState {
    running: bool
    suspended: bool
}

static mut APP_STATE = AppState {running: true, suspended:false}

To access these values, I must use unsafe like so: (Ignore the logic of code itself, just an example)

pub unsafe fn create_app {
    APP_STATE.running = true;
    APP_STATE.suspended = false;
}

unsafe fn confirm_app_state_valid() {
    if APP_STATE.running == APP_STATE.suspended { // equality on booleans is just the XNOR(Logical Bi-conditional) operator.
        fatal("Fatal! App was both running and suspended at same time. Could not resolve. Crashed")
    };
}

The Question

How can I change my code to

1. remove the unsafe (I understand why having unsafe is needed for mutable statics - avoid race conditions). Note that my app uses concurrency and performance is critical(graphics).

I want to remove the unsafe or atleast reduce its usage - currently it encompasses the entire main loop.

2. not have to pass state as an argument everywhere

Already looked at this. I did not understand how I might implement the solution provided here.

Answer 1

If you absolutely want some static global state, you can use once_cell in conjunction with a Mutex (see the example below).

However, I don't understand your remark « which is clearly not optimal » about passing the state as a parameter; do you mean inelegant or inefficient? Moreover, you state « performance is critical »; in my opinion, this static global state requiring runtime borrow checking at each access is less efficient than the usual static borrow checking.

use once_cell::sync::OnceCell;
use std::sync::{Mutex, MutexGuard};

#[derive(Debug)]
struct AppState {
    running: bool,
    suspended: bool,
}
static APP_STATE: OnceCell<Mutex<AppState>> = OnceCell::new();

fn access_app_state() -> MutexGuard<'static, AppState> {
    APP_STATE.get().unwrap().lock().unwrap()
}

fn confirm_app_state_valid() {
    let app_state = access_app_state();
    if app_state.running == app_state.suspended {
        panic!("Fatal! App was both running and suspended at same time...");
    }
    println!("App state is correct: {:?}", app_state);
}

fn change_app_state() {
    let mut app_state = access_app_state();
    app_state.running = !app_state.running;
    app_state.suspended = !app_state.suspended;
}

fn main() {
    APP_STATE
        .set(Mutex::new(AppState {
            running: true,
            suspended: false,
        }))
        .unwrap();
    confirm_app_state_valid();
    change_app_state();
    confirm_app_state_valid();
}
/*
App state is correct: AppState { running: true, suspended: false }
App state is correct: AppState { running: false, suspended: true }
*/

---

As stated by Chayim Friedman in a comment, since Rust 1.63 Mutex::new() is const. We can get rid of once_cell and just initialise the global mutex with a content which is known at compile-time.

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

#[derive(Debug)]
struct AppState {
    running: bool,
    suspended: bool,
}
static APP_STATE: Mutex<AppState> = Mutex::new(AppState {
    running: true,
    suspended: false,
});

fn access_app_state() -> MutexGuard<'static, AppState> {
    APP_STATE.lock().unwrap()
}

fn confirm_app_state_valid() {
    let app_state = access_app_state();
    if app_state.running == app_state.suspended {
        panic!("Fatal! App was both running and suspended at same time...");
    }
    println!("App state is correct: {:?}", app_state);
}

fn change_app_state() {
    let mut app_state = access_app_state();
    app_state.running = !app_state.running;
    app_state.suspended = !app_state.suspended;
}

fn main() {
    confirm_app_state_valid();
    change_app_state();
    confirm_app_state_valid();
}
/*
App state is correct: AppState { running: true, suspended: false }
App state is correct: AppState { running: false, suspended: true }
*/