Programmation concurrente en Rust

La gestion sûre et efficace de la concurrence est l'un des objectifs pour lesquels Rust a été créé, répondant principalement à la capacité du serveur à supporter une charge élevée.

Le concept de concurrence désigne différentes parties d'un programme s'exécutant indépendamment, ce qui est facilement confondu avec le concept de parallélisme ; le parallélisme met l'accent sur « l'exécution simultanée ».

La concurrence aboutit souvent au parallélisme.

Ce chapitre traite des concepts de programmation et des détails liés à la concurrence.

Fils de discussion

Un thread est une partie d'un programme qui s'exécute indépendamment.

La différence entre un thread et un processus est qu'un thread est un concept à l'intérieur d'un programme ; un programme s'exécute souvent dans un processus.

Dans un environnement doté d'un système d'exploitation, les processus sont souvent ordonnancés en alternance pour l'exécution, tandis que les threads sont ordonnancés par le programme au sein du processus.

Comme la concurrence entre threads est très susceptible d'entraîner du parallélisme, les erreurs d'interblocage et de retard rencontrées lors de l'exécution parallèle apparaissent souvent dans les programmes dotés de mécanismes de concurrence.

Pour résoudre ces problèmes, de nombreux autres langages (comme Java et C#) utilisent un logiciel d'exécution spécial pour coordonner les ressources, mais cela réduit sans aucun doute considérablement l'efficacité d'exécution du programme.

C/C++ prend en charge le multithreading au niveau le plus bas du système d'exploitation, mais le langage lui-même et ses compilateurs n'ont pas la capacité de détecter et d'éviter les erreurs parallèles, ce qui exerce une forte pression sur les développeurs ; les développeurs doivent consacrer beaucoup d'efforts à éviter les erreurs.

Rust ne dépend pas d'un environnement d'exécution, à l'instar de C/C++.

Mais Rust a conçu, au sein du langage lui-même, des mécanismes incluant le système de propriété pour éliminer autant que possible les erreurs les plus courantes au stade de la compilation, ce dont les autres langages ne disposent pas.

Mais cela ne signifie pas que nous pouvons être négligents lors de la programmation ; à ce jour, les problèmes causés par la concurrence n'ont pas été complètement résolus dans le domaine public, et des erreurs peuvent encore se produire. Soyez aussi prudents que possible lorsque vous programmez en concurrence !

En Rust, de nouveaux threads sont créés via la fonction std::thread::spawn :

Exemple

use std::thread;
use std::time::Duration;

fn spawn_function() {
    for i in 0..5 {
        println!("spawned thread print {}", i);
        thread::sleep(Duration::from_millis(1));
    }
}

fn main() {
    thread::spawn(spawn_function);

    for i in 0..3 {
        println!("main thread print {}", i);
        thread::sleep(Duration::from_millis(1));
    }
}

Sortie :

main thread print 0
spawned thread print 0
main thread print 1
spawned thread print 1
main thread print 2
spawned thread print 2

L'ordre de ce résultat peut changer dans certains cas, mais généralement c'est ainsi qu'il est imprimé.

Ce programme a un thread enfant qui imprime 5 lignes de texte, et le thread principal imprime 3 lignes de texte. Mais clairement, lorsque le thread principal se termine, le thread lancé se termine également sans terminer toute l'impression.

Le paramètre de la fonction std::thread::spawn est une fonction qui ne prend aucun paramètre, mais l'approche ci-dessus n'est pas recommandée. Nous pouvons utiliser des closures pour passer une fonction en argument :

Exemple

use std::thread;
use std::time::Duration;

fn main() {
    thread::spawn(|| {
        for i in 0..5 {
            println!("spawned thread print {}", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    for i in 0..3 {
        println!("main thread print {}", i);
        thread::sleep(Duration::from_millis(1));
    }
}

Une closure est une fonction anonyme qui peut être stockée dans une variable ou passée en argument à d'autres fonctions. Les closures sont équivalentes aux expressions Lambda en Rust, avec le format suivant :

|参数1, 参数2, ...| -> 返回值类型 {
    // 函数体
}

Par exemple :

Exemple

fn main() {
    let inc = |num: i32| -> i32 {
        num + 1
    };
    println!("inc(5) = {}", inc(5));
}

Sortie :

inc(5) = 6

Les closures peuvent omettre les déclarations de type et utiliser le mécanisme d'inférence de type automatique de Rust :

Exemple

fn main() {
    let inc = |num| {
        num + 1
    };
    println!("inc(5) = {}", inc(5));
}

Le résultat est inchangé.

méthode join

Exemple

use std::thread;
use std::time::Duration;

fn main() {
    let handle = thread::spawn(|| {
        for i in 0..5 {
            println!("spawned thread print {}", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    for i in 0..3 {
        println!("main thread print {}", i);
        thread::sleep(Duration::from_millis(1));
    }

    handle.join().unwrap();
}

Sortie :

main thread print 0 
spawned thread print 0 
spawned thread print 1 
main thread print 1 
spawned thread print 2 
main thread print 2 
spawned thread print 3 
spawned thread print 4

La méthode join fait que le programme ne cesse de s'exécuter qu'après que le thread enfant a fini.

move force le transfert de propriété

Il s'agit d'une situation couramment rencontrée :

Exemple

use std::thread;

fn main() {
    let s = "hello";
   
    let handle = thread::spawn(|| {
        println!("{}", s);
    });

    handle.join().unwrap();
}

Essayer d'utiliser les ressources de la fonction actuelle dans un thread enfant est absolument incorrect ! Car le mécanisme de propriété interdit cette situation dangereuse ; cela briserait la certitude de destruction des ressources que fournit le mécanisme de propriété. Nous pouvons utiliser le mot-clé move des fermetures pour gérer cela :

Exemple

use std::thread;

fn main() {
    let s = "hello";
   
    let handle = thread::spawn(move || {
        println!("{}", s);
    });

    handle.join().unwrap();
}

Passage de messages

Un outil principal en Rust pour implémenter la concurrence par passage de messages est le canal, qui se compose de deux parties : un émetteur et un récepteur.

std::sync::mpsc contient les méthodes pour le passage de messages :

Exemple

use std::thread;
use std::sync::mpsc;

fn main() {
    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        let val = String::from("hi");
        tx.send(val).unwrap();
    });

    let received = rx.recv().unwrap();
    println!("Got: {}", received);
}

Sortie :

Got: hi

Le thread enfant a obtenu l'émetteur tx du thread principal, a appelé sa méthode send pour envoyer une chaîne, puis le thread principal l'a reçue via le récepteur correspondant rx.

Autres extensions