En guide till Rusts orädda samtidighet

Samtidighet är förmågan hos ett program att utföra flera uppgifter samtidigt på samma CPU-kärna. Samtidiga uppgifter körs och slutförs i överlappande tid utan specificerad ordning, till skillnad från parallellism, där olika uppgifter eller deluppgifter av samma uppgift körs samtidigt på hårdvara med flera processorer.

Rust utmärker sig för sina prestandafunktioner och stöd för samtidighet på ett säkert och effektivt sätt. Rusts syn på samtidighet bygger på konceptet "orädd samtidighet" där språket syftar till att göra det enkelt att skriva säkert samtidig kod genom dess ägande- och lånesystem som upprätthåller strikta regler vid kompilering för att förhindra dataspår och säkerställer minne säkerhet.

Förstå samtidighet i rost

Rust tillhandahåller flera samtidiga primitiver för att skriva samtidiga program, inklusive trådar, meddelandeöverföring, mutexes, atomtyper och asynkron/avvaktar för asynkron programmering.

Här är en översikt över Rusts samtidighetsprimitiver:

1. Trådar: Rost ger en std:: tråd modul i sitt standardbibliotek för att skapa och hantera trådar. Du kan skapa nya trådar med tråd:: spawn fungera. De tråd:: spawn tar en stängning som innehåller koden för exekvering. Du kan också köra trådar som kan köras parallellt, och Rust tillhandahåller synkroniseringsprimitiver för att koordinera deras exekvering. Lånecheckaren säkerställer att referenser inte leder till oväntade beteenden.
2. Meddelande passerar: Rusts samtidighetsmodell stöder meddelandeöverföring mellan trådar. Du kommer att använda de kanaler som implementeras genom std:: sync:: mpsc modul för meddelandeöverföring. En kanal består av en sändare (Avsändare) och en mottagare (Mottagare). Trådar kan skicka meddelanden genom sändaren och ta emot dem via mottagaren. Detta ger ett säkert och synkroniserat sätt att kommunicera mellan trådar.
3. Mutexes och atomtyper: Rust ger synkroniseringsprimitiver, inklusive mutexer (std:: sync:: Mutex) och atomtyper (std:: sync:: atomic), för att säkerställa exklusiv åtkomst till datadelning. Mutexes tillåter flera trådar att komma åt data samtidigt samtidigt som de förhindrar dataraces. Atomtyper tillhandahåller atomoperationer på delad data, som att öka en räknare, utan att kräva explicit låsning.
4. Async/Await och Futures: Rosts asynkron/vänta syntax ger funktionalitet för att skriva asynkron kod som du kan köra samtidigt. Asynkrona program hanterar effektivt I/O-bundna uppgifter, vilket gör att program kan utföra andra uppgifter medan de väntar på andra I/O-operationer. Rusts asynkron/vänta syntax är baserad på terminer, och du kan driva dem med async-std eller tokio runtime-bibliotek.

Rostgängor är lätta, och frånvaron av driftstid gör dem väl lämpade för högpresterande applikationer. Rusts samtidighetsprimitiver integreras sömlöst med flera bibliotek och ramverk för olika samtidighetsbehov.

Hur man använder Spawn-trådar i rost

Du kommer att använda std:: tråd modul för att skapa trådar. De std:: tråd:: spawn funktionen låter dig skapa en ny tråd som körs samtidigt med huvudtråden eller andra befintliga trådar i ditt program.

Så här kan du skapa en tråd med std:: tråd:: spawn fungera:

använda sig av std:: tråd;
fnhuvud() {
// Skapa en ny tråd
låta thread_handle = thread:: spawn(|| {
// Koden som körs i den nya tråden går hit
println!("Hej från den nya tråden!");
 });
// Vänta tills den skapade tråden avslutas
 thread_handle.join().unwrap();
// Koden som körs i huvudtråden fortsätter här
println!("Hej från huvudtråden!");
}

De huvud funktionen skapar en ny tråd med tråd:: spawn funktion genom att skicka in en stängning som innehåller koden för exekveringen i tråden (i detta fall är stängningen en anonym funktion). Stängningen skriver ut ett meddelande som indikerar att den nya tråden körs.

De Ansluta sig metod på thread_handle låter huvudtråden vänta på att den skapade tråden slutförs. Genom att ringa Ansluta sig, ser funktionen till att huvudtråden väntar på att den skapade tråden ska slutföras innan du fortsätter.

Du kan skapa flera trådar och använda en slinga eller någon annan Rostkontrollstruktur för att skapa flera stängningar och skapa trådar för varje.

använda sig av std:: tråd;
fnhuvud() {
låta antal_trådar = 5;
låtamut thread_handles = vec![];
för i i0..antal_trådar {
låta thread_handle = tråd:: spawn(flytta || {
println!("Hej från tråden {}"i);
 });
 thread_handles.push (thread_handle);
 }
för hantera i trådhandtag {
 handle.join().unwrap();
 }
println!("Alla trådar avslutade!");
}

For-slingan skapar fem trådar, var och en tilldelad en unik identifierare i med loopvariabeln. Nedläggningarna fångar värdet av i med flytta nyckelord att undvika ägarfrågor, och den trådhandtag vektor lagrar trådarna för senare i Ansluta sig slinga.

Efter att ha skapat alla trådar, huvud funktion itererar över trådhandtag vektor, samtal Ansluta sig på varje handtag och väntar på att alla trådar ska köras.

Skicka meddelanden genom kanaler

Du kan skicka meddelanden genom trådar med kanaler. Rust ger funktionalitet för att skicka meddelanden i std:: sync:: mpsc modul. Här, mpsc står för "multiple producer, single consumer" och det tillåter kommunikation mellan flera trådar genom att skicka och ta emot meddelanden genom kanaler.

Så här implementerar du meddelanden som passerar genom kanaler för kommunikation mellan trådar i dina program:

använda sig av std:: sync:: mpsc;
använda sig av std:: tråd;
fnhuvud() {
// Skapa en kanal
låta (sändare, mottagare) = mpsc:: channel();
// Skapa en tråd
 tråd:: spawn(flytta || {
// Skicka ett meddelande via kanalen
 avsändare.sänd("Hej från tråden!").packa upp();
 });
// Ta emot meddelandet i huvudtråden
låta mottagen_meddelande = receiver.recv().unwrap();
println!("Mottaget meddelande: {}", mottaget_meddelande);
}

De huvud funktionen skapar en kanal med mpsc:: channel() som returnerar en avsändare och a mottagare. De avsändare skickar meddelanden till mottagare som tar emot meddelanden. De huvud funktionen fortsätter att skapa trådar och flytta äganderätten till Avsändare till trådförslutningen. Inuti trådförslutningen, den sender.send() funktionen skickar ett meddelande via kanalen.

De receiver.recv() funktion tar emot meddelandet genom att stoppa exekveringen tills tråden har tagit emot meddelandet. De huvud funktionen skriver ut meddelandet till konsolen efter ett lyckat meddelandemottagande.

Observera att att skicka ett meddelande via kanalen förbrukar avsändaren. Om du behöver skicka meddelanden från flera trådar kan du klona avsändaren med sender.clone() fungera.

Dessutom mpsc modulen ger andra metoder som try_recv(), vilken icke-blockerande försöker ta emot ett meddelande, och iter(), som skapar en iterator över de mottagna meddelandena.

Meddelandeförmedling via kanaler ger ett säkert och bekvämt sätt att kommunicera mellan trådar samtidigt som man undviker dataraces och säkerställer korrekt synkronisering.

Rusts ägande- och lånemodell garanterar minnessäkerhet

Rust kombinerar ägande, upplåning och lånekontrollen för att ge ett robust, säkert, samtidig programmeringsramverk.

Lånekontrollen fungerar som ett skyddsnät och upptäcker potentiella problem vid kompilering snarare än att förlita sig på körtidskontroller eller sophämtning.