Průvodce Rustovým neohroženým souběhem

Souběžnost je schopnost programu provádět více úloh současně na stejném jádru CPU. Souběžné úlohy běží a dokončují se v překrývajícím se čase bez zadaného pořadí, na rozdíl od paralelismu, kde různé úlohy nebo dílčí úlohy stejné úlohy běží současně na hardwaru s více procesory.

Rust vyniká svými výkonnostními vlastnostmi a podporou souběžnosti bezpečným a efektivním způsobem. Rustův přístup k souběžnosti je založen na konceptu „nebojácné souběžnosti“, kde jazyk usiluje o to, aby bylo snadné psát bezpečně. souběžný kód prostřednictvím systému vlastnictví a výpůjček, který vynucuje přísná pravidla v době kompilace, aby se zabránilo sledování dat a zajistila paměť bezpečnost.

Pochopení souběžnosti v Rustu

Rust poskytuje několik souběžných primitiv pro psaní souběžných programů, včetně vláken, předávání zpráv, mutexů, atomických typů a async/await pro asynchronní programování.

Zde je přehled Rustových souběžných primitiv:

1. Vlákna: Rez poskytuje a std:: vlákno modul ve své standardní knihovně pro vytváření a správu vláken. Můžete zakládat nová vlákna pomocí vlákno:: spawn funkce. The vlákno:: spawn vezme uzavření obsahující kód k provedení. Můžete také spouštět vlákna, která mohou běžet paralelně, a Rust poskytuje synchronizační primitiva pro koordinaci jejich provádění. Kontrolor půjček zajišťuje, že odkazy nevedou k neočekávanému chování.
2. Předávání zpráv: Rustův model souběžnosti podporuje předávání zpráv mezi vlákny. Budete používat kanály implementované prostřednictvím std:: synchronizace:: mpsc modul pro předávání zpráv. Kanál se skládá z vysílače (Odesílatel) a přijímač (Přijímač). Vlákna mohou odesílat zprávy přes vysílač a přijímat je přes přijímač. To poskytuje bezpečný a synchronizovaný způsob komunikace mezi vlákny.
3. Mutexy a atomové typy: Rust poskytuje synchronizační primitiva, včetně mutexů (std:: synchronizace:: Mutex) a atomové typy (std:: sync:: atomic), abychom zajistili výhradní přístup ke sdílení dat. Mutexy umožňují více vláknům souběžný přístup k datům a zároveň zabraňují závodům v datech. Atomické typy poskytují atomické operace se sdílenými daty, jako je inkrementace čítače, bez nutnosti explicitního zamykání.
4. Async/Await and Futures: Rust's asynchronní/čekat syntaxe poskytuje funkce pro psaní asynchronního kódu, který můžete spouštět souběžně. Asynchronní programy efektivně řeší úlohy vázané na I/O a umožňují programům provádět jiné úlohy a přitom čekat na jiné I/O operace. Rust's asynchronní/čekat syntaxe je založena na futures a můžete je napájet pomocí async-std nebo tokio runtime knihovny.

Rust vlákna jsou lehká a díky absenci režie běhu jsou vhodná pro vysoce výkonné aplikace. Rustova souběžná primitiva se hladce integrují do více knihoven a rámců pro různé potřeby souběžnosti.

Jak používat spawn vlákna v rzi

Budete používat std:: vlákno modul pro vytváření vláken. The std:: vlákno:: spawn Funkce umožňuje vytvořit nové vlákno, které poběží souběžně s hlavním vláknem nebo jakýmkoliv jiným existujícím vláknem ve vašem programu.

Zde je návod, jak můžete vytvořit vlákno pomocí std:: vlákno:: spawn funkce:

použití std:: závit;
fnhlavní() {
// Založí nové vlákno
nechat thread_handle = thread:: spawn(|| {
// Kód spuštěný v novém vlákně jde sem
println!("Ahoj z nového vlákna!");
 });
// Počkejte na dokončení vytvořeného vlákna
 thread_handle.join().unwrap();
// Kód spuštěný v hlavním vlákně pokračuje zde
println!("Ahoj z hlavního vlákna!");
}

The hlavní funkce vytvoří nové vlákno s vlákno:: spawn funkce předáním uzavření obsahujícího kód pro provedení ve vláknu (v tomto případě je uzavření anonymní funkcí). Uzavření vytiskne zprávu oznamující, že je spuštěno nové vlákno.

The připojit metoda na rukojeť_vlákna umožňuje hlavnímu vláknu čekat na dokončení spuštěného vlákna. Zavoláním připojit, funkce zajišťuje, že hlavní vlákno čeká na dokončení vytvořeného vlákna, než bude pokračovat.

Můžete vytvořit více vláken a použít smyčku nebo jakoukoli jinou Struktura kontroly rzi pro vytvoření více uzávěrů a spawn vláken pro každé z nich.

použití std:: závit;
fnhlavní() {
nechat num_threads = 5;
nechatmut nitě_držadla = vec![];
pro i v0..num_threads {
nechat thread_handle = thread:: spawn(hýbat se || {
println!("Dobrý den z vlákna {}", i);
 });
 thread_handles.push (thread_handle);
 }
pro Rukojeť v úchyty_vlákna {
 handle.join().unwrap();
 }
println!("Všechna vlákna dokončena!");
}

Smyčka for vytvoří pět vláken, z nichž každé je přiřazeno jedinečnému identifikátoru i s proměnnou smyčky. Uzávěry zachytit hodnotu i s hýbat se klíčové slovo, kterému se vyhnout vlastnické záležitostia nitě_držadla vector ukládá vlákna pro pozdější použití připojit smyčka.

Po vytvoření všech vláken, hlavní funkce iteruje přes nitě_držadla vektor, volání připojit na každém úchytu a čeká na provedení všech vláken.

Předávání zpráv přes kanály

Zprávy můžete předávat vlákny s kanály. Rust poskytuje funkce pro předávání zpráv v std:: synchronizace:: mpsc modul. Tady, mpsc je zkratka pro "multiple producent, single customer" a umožňuje komunikaci mezi více vlákny odesíláním a přijímáním zpráv prostřednictvím kanálů.

Zde je návod, jak ve svých programech implementujete předávání zpráv prostřednictvím kanálů mezivláknové komunikace:

použití std:: synchronizace:: mpsc;
použití std:: závit;
fnhlavní() {
// Vytvořte kanál
nechat (odesílatel, příjemce) = mpsc:: channel();
// Založí vlákno
 vlákno:: spawn(hýbat se || {
// Odeslat zprávu prostřednictvím kanálu
 odesílatel.odeslat("Ahoj z vlákna!").rozbalit();
 });
// Přijetí zprávy v hlavním vlákně
nechat přijatá_zpráva = receiver.recv().unwrap();
println!("Přijatá zpráva: {}", přijatá_zpráva);
}

The hlavní funkce vytvoří kanál s mpsc:: kanál() která vrací a odesílatel a a přijímač. The odesílatel posílá zprávy na přijímač která přijímá zprávy. The hlavní funkce pokračuje k vytvoření vláken a přesunutí vlastnictví Odesílatel k uzávěru závitu. Uvnitř závitového uzávěru je odesílatel.odeslat() funkce odešle zprávu prostřednictvím kanálu.

The receiver.recv() funkce přijme zprávu zastavením provádění, dokud vlákno nepřijme zprávu. The hlavní funkce vytiskne zprávu do konzole po úspěšném přijetí zprávy.

Všimněte si, že odeslání zprávy přes kanál spotřebovává odesílatele. Pokud potřebujete odesílat zprávy z více vláken, můžete naklonovat odesílatele pomocí odesílatel.klon() funkce.

Kromě toho, mpsc modul poskytuje další metody jako try_recv(), který se neblokující pokusí přijmout zprávu, a iter(), který vytvoří iterátor nad přijatými zprávami.

Předávání zpráv prostřednictvím kanálů poskytuje bezpečný a pohodlný způsob komunikace mezi vlákny, přičemž se vyhýbá datovým závodům a zajišťuje správnou synchronizaci.

Model vlastnictví a půjčování Rust zaručuje bezpečnost paměti

Rust kombinuje vlastnictví, půjčování a kontrolu půjček a poskytuje robustní, bezpečný a souběžný programovací rámec.

Nástroj pro kontrolu výpůjček funguje jako záchranná síť, která zjišťuje potenciální problémy v době kompilace, místo aby se spoléhala na kontroly za běhu nebo shromažďování odpadu.