Variables globales en Rust : mythes, réalité et alternatives sécurisées

Introduction : "Où sont les variables globales ?" — le premier choc du débutant en Rust

Vous venez de commencer à apprendre Rust, vous avez écrit quelques programmes, et soudain vous réalisez : vous avez besoin qu'une variable soit accessible depuis n'importe quel point du code. En Python ou JavaScript, vous écririez simplement global_var = 42 au niveau supérieur — et c'est fait. Mais en Rust... le compilateur vous regarde d'un air réprobateur et affiche une erreur.

La question "Is it possible to use global variables in Rust?" est l'une des plus populaires sur Stack Overflow. Et ce n'est pas sans raison. Rust, contrairement à de nombreux langages, ne permet pas de déclarer une variable globale simplement. Pourquoi ? Parce que la sécurité mémoire n'est pas qu'un mot à la mode, c'est le fondement du langage.

Dans cet article, nous analyserons toutes les méthodes pour travailler avec des données globales en Rust : des simples constantes aux stockages thread-safe. Vous apprendrez à contourner les limitations du compilateur sans sacrifier la sécurité, et quand les variables globales sont un mal nécessaire ou une nécessité.

Pourquoi Rust interdit-il les variables globales "normales" ?

Avant de chercher des solutions, comprenons le problème. Rust applique des règles strictes de possession (ownership) et d'emprunt (borrowing). Une variable globale qui peut être modifiée depuis n'importe quel thread à tout moment est une voie directe vers une course aux données (data race).

Imaginez : deux threads tentent simultanément d'écrire des valeurs différentes dans la même variable globale. Le résultat est imprévisible. En C++ ou C, cela conduit à un comportement indéfini. Rust garantit qu'un tel code ne compilera tout simplement pas.

C'est pourquoi le compilateur exige que nous spécifiions explicitement :

\n
• La variable est immuable ? Utilisez const ou static.
\n
• La variable est mutable et utilisée dans un seul thread ? Utilisez static mut (avec unsafe).
\n
• La variable est mutable et utilisée dans plusieurs threads ? Utilisez Mutex, RwLock ou des types atomiques.
\n

Méthode 1 : Les constantes (const) — l'option la plus sûre

Si votre "valeur globale" est en réalité une constante qui ne change jamais, utilisez const :

const MAX_CONNECTIONS: u32 = 100;\nconst DATABASE_URL: &str = "postgresql://localhost:5432/mydb";\n\nfn main() {\n    println!("Maximum de connexions : {}", MAX_CONNECTIONS);\n}

Les constantes en Rust ne sont pas de simples variables. Elles sont inlinées par le compilateur à l'endroit de leur utilisation. C'est-à-dire qu'à la compilation, MAX_CONNECTIONS sera remplacée par le nombre 100. C'est efficace, mais cela signifie que la constante n'a pas d'adresse mémoire fixe. Si vous avez besoin d'un emplacement mémoire (par exemple pour FFI), utilisez static.

Méthode 2 : Les variables statiques (static)

Si vous avez besoin d'une variable globale avec une adresse mémoire fixe, utilisez static :

static APP_NAME: &str = "My Rust Application";\nstatic VERSION: u32 = 1;\n\nfn main() {\n    println!("Lancement de {} version {}", APP_NAME, VERSION);\n}

Par défaut, les variables static sont immuables. Cela garantit la sécurité dans un environnement multithread. Mais que faire si vous devez modifier un état global ?

Méthode 3 : Les variables statiques mutables (static mut) — attention, unsafe !

Rust permet de déclarer une variable statique mutable avec static mut. Mais il y a un piège : toute lecture ou écriture de cette variable nécessite un bloc unsafe.

static mut COUNTER: u32 = 0;\n\nfn increment() {\n    unsafe {\n        COUNTER += 1;\n    }\n}\n\nfn main() {\n    increment();\n    unsafe {\n        println!("Compteur : {}", COUNTER);\n    }\n}

Important :