Comment puis-je créer le mondial, mutable singleton?

Non-réponse réponse

Éviter global de l'état en général. Au lieu de cela, construire l'objet quelque part au début (peut-être dans main), puis passer mutable les références à cet objet dans les lieux qui en ont besoin. Il s'agit généralement de rendre votre code plus facile à comprendre et ne nécessite pas autant de pencher en arrière.

Regard dur à vous-même dans le miroir avant de décider que vous voulez mondiale mutable variables. Il existe de rares cas où c'est utile, c'est pourquoi il est bon de savoir comment le faire.

Encore envie de faire une...?

À l'aide de paresseux-statique

La paresseux-statique caisse peut enlever un peu de la corvée de la création d'un singleton (ci-dessous). Voici un mondial mutable vecteur:

#[macro_use]
extern crate lazy_static;

use std::sync::Mutex;

lazy_static! {
    static ref ARRAY: Mutex<Vec<u8>> = Mutex::new(vec![]);
}

fn do_a_call() {
    ARRAY.lock().unwrap().push(1);
}

fn main() {
    do_a_call();
    do_a_call();
    do_a_call();

    println!("called {}", ARRAY.lock().unwrap().len());
}

Si vous supprimez le Mutex alors vous avez un mondial singleton sans mutabilité.

Un cas particulier: les atomics

Si vous avez seulement besoin de suivre un entier de valeur, vous pouvez utiliser directement un atomique:

use std::sync::atomic::{AtomicUsize, Ordering};

static CALL_COUNT: AtomicUsize = AtomicUsize::new(0);

fn do_a_call() {
    CALL_COUNT.fetch_add(1, Ordering::SeqCst);
}

fn main() {
    do_a_call();
    do_a_call();
    do_a_call();

    println!("called {}", CALL_COUNT.load(Ordering::SeqCst));
}

Manuel, dépendance-gratuit de mise en œuvre

C'est grandement chipé par la Rouille 1.0 mise en œuvre de stdin. Vous devriez aussi regarder à la moderne, la mise en œuvre de io::Lazy. J'ai commenté en ligne avec ce que chaque ligne ne.

use std::sync::{Arc, Mutex, Once, ONCE_INIT};
use std::time::Duration;
use std::{mem, thread};
#[derive(Clone)]
struct SingletonReader {
//Since we will be used in many threads, we need to protect
//concurrent access
inner: Arc<Mutex<u8>>,
}
fn singleton() -> SingletonReader {
//Initialize it to a null value
static mut SINGLETON: *const SingletonReader = 0 as *const SingletonReader;
static ONCE: Once = ONCE_INIT;
unsafe {
ONCE.call_once(|| {
//Make it
let singleton = SingletonReader {
inner: Arc::new(Mutex::new(0)),
};
//Put it in the heap so it can outlive this call
SINGLETON = mem::transmute(Box::new(singleton));
});
//Now we give out a copy of the data that is safe to use concurrently.
(*SINGLETON).clone()
}
}
fn main() {
//Let's use the singleton in a few threads
let threads: Vec<_> = (0..10)
.map(|i| {
thread::spawn(move || {
thread::sleep(Duration::from_millis(i * 10));
let s = singleton();
let mut data = s.inner.lock().unwrap();
*data = i as u8;
})
})
.collect();
//And let's check the singleton every so often
for _ in 0u8..20 {
thread::sleep(Duration::from_millis(5));
let s = singleton();
let data = s.inner.lock().unwrap();
println!("It is: {}", *data);
}
for thread in threads.into_iter() {
thread.join().unwrap();
}
}

Cette affiche:

It is: 0
It is: 1
It is: 1
It is: 2
It is: 2
It is: 3
It is: 3
It is: 4
It is: 4
It is: 5
It is: 5
It is: 6
It is: 6
It is: 7
It is: 7
It is: 8
It is: 8
It is: 9
It is: 9
It is: 9

Ce code compile avec de la Rouille 1.23.0. Le réel implémentations de Stdin utiliser certaines fonctionnalités instables pour tenter de libérer la mémoire allouée, que le présent code ne fonctionne pas.

Vraiment, vous auriez probablement souhaitez faire SingletonReader mettre en œuvre Deref et DerefMut si vous n'avez pas à fouiner dans l'objet et de la serrure elle-même.

Ensemble de ce travail est que paresseux-statique fait pour vous.

Le sens de "global"

Veuillez noter que vous pouvez toujours utiliser la normale de la Rouille détermination de la portée et au niveau du module de confidentialité pour contrôler l'accès à un static ou lazy_static variable. Cela signifie que vous pouvez déclarer dans un module ou même à l'intérieur d'une fonction et il ne sera pas accessible de l'extérieur de ce module ou une fonction. C'est bon pour le contrôle de l'accès:

use lazy_static::lazy_static; //1.2.0
fn only_here() {
lazy_static! {
static ref NAME: String = String::from("hello, world!");
}
println!("{}", &*NAME);
}
fn not_here() {
println!("{}", &*NAME);
}

error[E0425]: cannot find value `NAME` in this scope
--> src/lib.rs:12:22
|
12 |     println!("{}", &*NAME);
|                      ^^^^ not found in this scope

Cependant, la variable est toujours global qu'il n'y a qu'une seule instance de ce qui existe à travers l'ensemble du programme.