Is it possible to use global variables in Rust?

It's possible, but heap allocation is not allowed directly. Heap allocation is performed at runtime. Here are a few examples:

static SOME_INT: i32 = 5;
static SOME_STR: &'static str = "A static string";
static SOME_STRUCT: MyStruct = MyStruct {
    number: 10,
    string: "Some string",
};
static mut db: Option<sqlite::Connection> = None;

fn main() {
    println!("{}", SOME_INT);
    println!("{}", SOME_STR);
    println!("{}", SOME_STRUCT.number);
    println!("{}", SOME_STRUCT.string);

    unsafe {
        db = Some(open_database());
    }
}

struct MyStruct {
    number: i32,
    string: &'static str,
}

You can use static variables fairly easily as long as they are thread-local.

The downside is that the object will not be visible to other threads your program might spawn. The upside is that unlike truly global state, it is entirely safe and is not a pain to use - true global state is a massive pain in any language. Here's an example:

extern mod sqlite;

use std::cell::RefCell;

thread_local!(static ODB: RefCell<sqlite::database::Database> = RefCell::new(sqlite::open("test.db"));

fn main() {
    ODB.with(|odb_cell| {
        let odb = odb_cell.borrow_mut();
        // code that uses odb goes here
    });
}

Here we create a thread-local static variable and then use it in a function. Note that it is static and immutable; this means that the address at which it resides is immutable, but thanks to RefCell the value itself will be mutable.

Unlike regular static, in thread-local!(static ...) you can create pretty much arbitrary objects, including those that require heap allocations for initialization such as Vec, HashMap and others.

If you cannot initialize the value right away, e.g. it depends on user input, you may also have to throw Option in there, in which case accessing it gets a bit unwieldy:

extern mod sqlite;

use std::cell::RefCell;

thread_local!(static ODB: RefCell<Option<sqlite::database::Database>> = RefCell::New(None));

fn main() {
    ODB.with(|odb_cell| {
        // assumes the value has already been initialized, panics otherwise
        let odb = odb_cell.borrow_mut().as_mut().unwrap();
        // code that uses odb goes here
    });
}

Look at the const and static section of the Rust book.

You can use something like the following:

const N: i32 = 5;

or

static N: i32 = 5;

in the global space.

But these are not mutable. For mutability, you could use something like:

static mut N: i32 = 5;

Then reference them like:

unsafe {
    N += 1;

    println!("N: {}", N);
}

I am new to Rust, but this solution seems to work:

#[macro_use]
extern crate lazy_static;

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

lazy_static! {
    static ref GLOBAL: Arc<Mutex<GlobalType> =
        Arc::new(Mutex::new(GlobalType::new()));
}

Another solution is to declare a crossbeam channel transmit/receive pair as an immutable global variable. The channel should be bounded and can only hold one element. When you initialize the global variable, push the global instance into the channel. When using the global variable, pop the channel to acquire it and push it back when done using it.

Both solutions should provide a safe approach to using global variables.

Heap allocations are possible for static variables if you use the lazy_static macro as seen in the documentation:

Using this macro, it is possible to have statics that require code to be executed at runtime in order to be initialized. This includes anything requiring heap allocations, like vectors or hash maps, as well as anything that requires function calls to be computed.

// Declares a lazily evaluated constant HashMap. The HashMap will be evaluated once and
// stored behind a global static reference.

use lazy_static::lazy_static;
use std::collections::HashMap;

lazy_static! {
    static ref PRIVILEGES: HashMap<&'static str, Vec<&'static str>> = {
        let mut map = HashMap::new();
        map.insert("James", vec!["user", "admin"]);
        map.insert("Jim", vec!["user"]);
        map
    };
}

fn show_access(name: &str) {
    let access = PRIVILEGES.get(name);
    println!("{}: {:?}", name, access);
}

fn main() {
    let access = PRIVILEGES.get("James");
    println!("James: {:?}", access);

    show_access("Jim");
}

I think this page covers most aspects well https://www.sitepoint.com/rust-global-variables/

As of Rust 1.70, there is also the OnceLock synchronization primitive we could use in cases where we just need a static global variable that is initialized (written to) only once.

Here is an example of a static global read-only HashMap:

use std::collections::HashMap;
use std::sync::OnceLock;

static GLOBAL_MAP: OnceLock<HashMap<String, i32>> = OnceLock::new();

fn main() {
    let m = get_hash_map_ref();
    assert_eq!(m.get("five"), Some(&5));
    assert_eq!(m.get("seven"), None);
    std::thread::spawn(|| {    
        let m = get_hash_map_ref();
        println!("From another thread: {:?}", m.get("five"));
    }).join().unwrap();
}

fn get_hash_map_ref() -> &'static HashMap<String, i32> {
    GLOBAL_MAP.get_or_init(|| {
        create_fixed_hash_map()
    })
}

fn create_fixed_hash_map() -> HashMap<String, i32> {
    let mut m = HashMap::new();
    m.insert("five".to_owned(), 5);
    m.insert("ten".to_owned(), 10);
    m
}

As can be seen, that map can be accessed from different threads.

Note that HashMap::new() is not const (at least not yet) and that's why we (still) cannot have something like const MY_MAP: HashMap<...> = ... in Rust.

Use crate once_cell or lazy_static, or SyncOnceCell in nightly.

The simplest method is to use a mutex. A mutex, or "mutual exclusion", is a synchronization primitive provided by your OS that prevents different threads from simultaneously accessing some data. When one thread calls lock() on the mutex when it's already been locked, that thread will "freeze" until the first lock has been dropped.

use std::sync::Mutex;

static GLOBAL_STRING: Mutex<String> = Mutex::new(String::new());

fn mutate_global() {
    let mut lock = GLOBAL_STRING.lock().unwrap();
    lock.push_str("Hello, world!");
    // Until we drop the lock, no other thread has access to the global.
}

fn main() {
    mutate_global();
    println!("{}", GLOBAL_STRING.lock().unwrap());
}

Here's how to do it unsafely (avoiding OS overhead). Note that using static mut as described in the top answer is discouraged as it is considered to be overly easy to misuse, but nightly-only SyncUnsafeCell can do the same thing using the "interior mutability" pattern.

The code is now unsafe because if multiple threads call mutate_global() at the same time, they would both hold a &mut reference to the inner String, which is undefined behaviour.

#![feature(sync_unsafe_cell)]
use std::cell::SyncUnsafeCell;

static GLOBAL_STRING: SyncUnsafeCell<String> = SyncUnsafeCell::new(String::new());

fn mutate_global() {
    // SAFETY: No other part of the program can concurrently access `GLOBAL_STRING`.
    let unique_borrow = unsafe { &mut *GLOBAL_STRING.get() };
    unique_borrow.push_str("Hello, world!");
}

fn main() {
    mutate_global();

    // SAFETY: No other part of the program can concurrently write to `GLOBAL_STRING`.
    println!("{}", unsafe { &*GLOBAL_STRING.get() });
}

SyncUnsafeCell is just a wrapper around UnsafeCell that implements Sync, so if you don't have access to the nightly compiler, you can easily reimplement and import it like so:

mod polyfill {
    use core::cell::UnsafeCell;
    use core::ops::Deref;

    pub struct SyncUnsafeCell<T>(UnsafeCell<T>);

    impl<T> SyncUnsafeCell<T> {
        pub const fn new(inner: T) -> Self {
            SyncUnsafeCell(UnsafeCell::new(inner))
        }
    }

    impl<T> Deref for SyncUnsafeCell<T> {
        type Target = UnsafeCell<T>;

        fn deref(&self) -> &Self::Target {
            &self.0
        }
    }

    // This is the important part:
    unsafe impl<T> Sync for SyncUnsafeCell<T> {}
}

use polyfill::SyncUnsafeCell;

The other answers here directly respond to the OP's query, but for anyone looking for help specifically re: safely sharing state in the context of a web server, it is (in my opinion) worth mentioning the amazing web framework actix (I'm not involved with the project aside from benefiting greatly as a user of it).

actix supports "inversion of control" such that state -- like a settings struct that reads from env vars, or a database connection -- can be propagated safely from the top layer of the app down, with downstream handlers etc. simply registering their need for certain state or functionality, basically through defining an input parameter corresponding to the type of that state (axtic refers to this pattern under the term extractors).

For example, consider this web server:

type DbPool = r2d2::Pool<r2d2::ConnectionManager<SqliteConnection>>;

#[actix_web::main]
async fn main() -> io::Result<()> {
    // connect to SQLite DB
    let manager = r2d2::ConnectionManager::<SqliteConnection>::new("app.db");
    let pool = r2d2::Pool::builder()
        .build(manager)
        .expect("database URL should be valid path to SQLite DB file");

    // start HTTP server on port 8080
    HttpServer::new(move || {
        App::new()
            .app_data(web::Data::new(pool.clone()))
            .route("/{name}", web::get().to(index))
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

This line:

.app_data(web::Data::new(pool.clone()))

indicates that there is a database-connection pool available. In a handler, web::Data<T> tells actix to check whatever was set up via .app_data for something matching T, which in this case is DbPool:

async fn index(
    pool: web::Data<DbPool>,
    name: web::Path<(String,)>,
) -> actix_web::Result<impl Responder> {
    ...
}

Here are the docs for database integrations in actix, and here are their more general docs on "extractors." tl;dr for anyone trying to share state in the context of a web server, actix exists and is great for this.