Mutable Static Variables

It is safe to read an immutable static variable:

  1. static HELLO_WORLD: &str = "Hello, world!";
  3. fn main() {
  4.     println!("HELLO_WORLD: {HELLO_WORLD}");
  5. }

However, since data races can occur, it is unsafe to read and write mutable static variables:

  1. static mut COUNTER: u32 = 0;
  3. fn add_to_counter(inc: u32) {
  4.     // SAFETY: There are no other threads which could be accessing `COUNTER`.
  5.     unsafe {
  6.         COUNTER += inc;
  7.     }
  8. }
  10. fn main() {
  11.     add_to_counter(42);
  13.     // SAFETY: There are no other threads which could be accessing `COUNTER`.
  14.     unsafe {
  15.         println!("COUNTER: {COUNTER}");
  16.     }
  17. }

This slide should take about 5 minutes.

  • The program here is safe because it is single-threaded. However, the Rust compiler is conservative and will assume the worst. Try removing the unsafe and see how the compiler explains that it is undefined behavior to mutate a static from multiple threads.

  • Using a mutable static is generally a bad idea, but there are some cases where it might make sense in low-level no_std code, such as implementing a heap allocator or working with some C APIs.