Compiler Explorer

Source code

use std::sync::Once;
use std::cell::Cell;
use std::hint::unreachable_unchecked;

// Static with runtime state

struct Test {
  pub a : Box<i32>,
}

fn get_static() -> &'static Test {
  
  // struct that stores our data + a lock guard
  struct Stt {
    data: Cell<Option<Test>>,
    once: Once // lock guard to make sure static is set only once
  }
  // static variable type must have the Sync trait bound.
  // and we also make sure that Stt can only be accessed in a thread safe manner.
  unsafe impl Sync for Stt {}

// static variable
  static A: Stt = Stt{data: Cell::new(None), once: Once::new() };  
 
  // lock, call_once makes sure that the block is execture only once
  A.once.call_once(|| {

// init static with a state at runtime - Heap allocation
    A.data.set(Some(Test{a: Box::new(5)}));
  });

// get reference, dereferencing a raw pointer is unsafe
  let v = unsafe { match *A.data.as_ptr() { 
      Some(ref a) => a,
      None => {
        // unreachable code, we are sure that data is never None
        unreachable_unchecked();
      }
  }};

return v;
}

pub fn main() {

let a = get_static(); // reference to static
    let b = get_static(); // another reference to static

// print address
    println!("{:p} {:p}", a as *const Test, b as *const Test);
}