Przewodnik po nieustraszonej współbieżności Rusta

Współbieżność to zdolność programu do wykonywania wielu zadań jednocześnie na tym samym rdzeniu procesora. Równoległe zadania są uruchamiane i wykonywane w nakładającym się czasie bez określonej kolejności, w przeciwieństwie do równoległości, gdzie różne zadania lub podzadania tego samego zadania działają w tym samym czasie na sprzęcie z wieloma procesory.

Rust wyróżnia się funkcjami wydajnościowymi i obsługą współbieżności w bezpieczny i wydajny sposób. Podejście Rust do współbieżności opiera się na koncepcji „nieustraszonej współbieżności”, w której język ma na celu ułatwienie bezpiecznego pisania współbieżny kod poprzez swój system własności i wypożyczania, który wymusza ścisłe reguły w czasie kompilacji, aby zapobiec śledzeniu danych i zapewnić pamięć bezpieczeństwo.

Zrozumienie współbieżności w Rust

Rust zapewnia kilka prymitywów współbieżności do pisania programów współbieżnych, w tym wątki, przekazywanie komunikatów, muteksy, typy atomowe i async/oczekiwanie na programowanie asynchroniczne.

Oto przegląd prymitywów współbieżności Rusta:

1. Wątki: Rdza zapewnia std:: wątek moduł w swojej standardowej bibliotece do tworzenia wątków i zarządzania nimi. Możesz odradzać nowe wątki za pomocą wątek:: odrodzenie funkcjonować. The wątek:: odrodzenie przyjmuje zamknięcie zawierające kod do wykonania. Możesz także uruchamiać wątki, które mogą działać równolegle, a Rust zapewnia prymitywy synchronizacji do koordynowania ich wykonywania. Kontroler pożyczkowy zapewnia, że ​​odwołania nie prowadzą do nieoczekiwanych zachowań.
2. Przekazywanie wiadomości: Model współbieżności Rust obsługuje przekazywanie komunikatów między wątkami. Będziesz korzystać z kanałów zaimplementowanych przez std:: sync:: mpsc moduł do przekazywania wiadomości. Kanał składa się z nadajnika (Nadawca) i odbiornik (Odbiorca). Wątki mogą wysyłać wiadomości przez nadajnik i odbierać je przez odbiornik. Zapewnia to bezpieczny i zsynchronizowany sposób komunikacji między wątkami.
3. Muteksy i typy atomowe: Rust zapewnia prymitywy synchronizacji, w tym muteksy (std:: sync:: Mutex) i typy atomowe (std:: synchronizacja:: atomowa), aby zapewnić wyłączny dostęp do udostępniania danych. Muteksy umożliwiają wielu wątkom równoczesny dostęp do danych, jednocześnie zapobiegając wyścigom danych. Typy atomowe zapewniają niepodzielne operacje na udostępnionych danych, takie jak zwiększanie licznika, bez konieczności jawnego blokowania.
4. Asynchroniczne/oczekiwane i futures: Rdza asynchroniczny/czekać na Składnia zapewnia funkcjonalność do pisania kodu asynchronicznego, który można wykonywać jednocześnie. Programy asynchroniczne skutecznie radzą sobie z zadaniami związanymi z wejściem/wyjściem, umożliwiając programom wykonywanie innych zadań w oczekiwaniu na inne operacje wejścia/wyjścia. Rusta asynchroniczny/czekać na Składnia jest oparta na kontraktach futures i możesz je zasilać za pomocą standard asynchroniczny Lub Tokio biblioteki uruchomieniowe.

Wątki Rust są lekkie, a brak narzutu czasu wykonywania sprawia, że ​​doskonale nadają się do aplikacji o wysokiej wydajności. Prymitywy współbieżności Rusta bezproblemowo integrują się z wieloma bibliotekami i frameworkami dla różnych potrzeb współbieżności.

Jak używać wątków odradzających się w Rust

Użyjesz std:: wątek moduł do spawnowania wątków. The std:: wątek:: spawn Funkcja pozwala na utworzenie nowego wątku, który będzie działał równolegle z głównym wątkiem lub innymi istniejącymi wątkami w twoim programie.

Oto jak możesz odrodzić wątek z std:: wątek:: spawn funkcjonować:

używać std:: wątek;
przypgłówny() {
// Rozpocznij nowy wątek
pozwalać uchwyt_wątku = wątek:: spawn(|| {
// Kod wykonany w nowym wątku trafia tutaj
drukuj!("Cześć z nowego wątku!");
 });
// Poczekaj na zakończenie zrodzonego wątku
 thread_handle.join().unwrap();
// Kod wykonany w głównym wątku jest kontynuowany tutaj
drukuj!("Cześć z głównego wątku!");
}

The główny funkcja tworzy nowy wątek z wątek:: odrodzenie poprzez przekazanie zamknięcia zawierającego kod do wykonania w wątku (w tym przypadku zamknięcie jest funkcją anonimową). Zamknięcie drukuje komunikat wskazujący, że nowy wątek jest uruchomiony.

The dołączyć metoda na uchwyt_wątku pozwala głównemu wątkowi czekać na zakończenie wykonywania zrodzonego wątku. Poprzez dzwonienie dołączyć, funkcja zapewnia, że ​​główny wątek czeka na zakończenie zrodzonego wątku przed kontynuowaniem.

Możesz odrodzić wiele wątków i użyć pętli lub dowolnej innej Struktura kontroli rdzy aby utworzyć wiele zamknięć i odradzać wątki dla każdego.

używać std:: wątek;
przypgłówny() {
pozwalać liczba_wątków = 5;
pozwalaćmut uchwyty_wątków = vec![];
Do I W0..num_wątków {
pozwalać uchwyt_wątku = wątek:: spawn(przenosić || {
drukuj!(„Witam z wątku {}”, I);
 });
 uchwyt_wątku.push (uchwyt_wątku);
 }
Do uchwyt W uchwyty_wątków {
 handle.join().unwrap();
 }
drukuj!("Wszystkie wątki zakończone!");
}

Pętla for tworzy pięć wątków, z których każdy ma przypisany unikalny identyfikator I ze zmienną pętli. Zamknięcia przechwytują wartość I z przenosić słowo kluczowe, którego należy unikać kwestie własnościowe, i uchwyty_wątków vector przechowuje wątki na później w dołączyć pętla.

Po spawnowaniu wszystkich wątków, główny funkcja iteruje po uchwyty_wątków wektor, rozmowy dołączyć na każdym uchwycie i czeka na wykonanie wszystkich wątków.

Przekazywanie wiadomości kanałami

Możesz przekazywać wiadomości przez wątki z kanałami. Rust zapewnia funkcjonalność przekazywania wiadomości w std:: sync:: mpsc moduł. Tutaj, mpsc oznacza „wielu producentów, jednego konsumenta” i umożliwia komunikację między wieloma wątkami poprzez wysyłanie i odbieranie wiadomości za pośrednictwem kanałów.

Oto jak wdrażasz przekazywanie wiadomości przez kanały komunikacji między wątkami w swoich programach:

używać std:: sync:: mpsc;
używać std:: wątek;
przypgłówny() {
// Utwórz kanał
pozwalać (nadawca, odbiorca) = mpsc:: kanał();
// Rozpocznij wątek
 wątek:: spawn(przenosić || {
// Wyślij wiadomość przez kanał
 nadawca.wyślij("Cześć z wątku!").odwijać się();
 });
// Odbierz wiadomość w głównym wątku
pozwalać odebrana_wiadomość = odbiornik.recv().unwrap();
drukuj!("Otrzymana wiadomość: {}", otrzymana_wiadomość);
}

The główny funkcja tworzy kanał z mpsc:: kanał() to zwraca a nadawca i odbiorca. The nadawca wysyła wiadomości do odbiorca który odbiera wiadomości. The główny funkcja kontynuuje odradzanie wątków i przenoszenie własności Nadawca do zamknięcia wątku. Wewnątrz zamknięcia nici, nadawca.wyślij() funkcja wysyła wiadomość przez kanał.

The odbiornik.recv() funkcja odbiera komunikat, wstrzymując wykonywanie, dopóki wątek nie otrzyma komunikatu. The główny funkcja drukuje komunikat na konsoli po pomyślnym odebraniu komunikatu.

Należy pamiętać, że wysłanie wiadomości za pośrednictwem kanału zużywa nadawcę. Jeśli musisz wysyłać wiadomości z wielu wątków, możesz sklonować nadawcę za pomocą nadawca.klon() funkcjonować.

Dodatkowo, mpsc moduł zapewnia inne metody, takie jak try_recv(), który nieblokujący próbuje odebrać wiadomość, oraz iter(), który tworzy iterator nad odebranymi wiadomościami.

Przekazywanie wiadomości kanałami zapewnia bezpieczny i wygodny sposób komunikowania się między wątkami przy jednoczesnym uniknięciu wyścigu danych i zapewnieniu odpowiedniej synchronizacji.

Model własności i pożyczania w Rust gwarantuje bezpieczeństwo pamięci

Rust łączy własność, wypożyczanie i sprawdzanie wypożyczeń, aby zapewnić solidną, bezpieczną i współbieżną platformę programowania.

Narzędzie do sprawdzania wypożyczeń działa jak siatka bezpieczeństwa, wykrywając potencjalne problemy w czasie kompilacji, zamiast polegać na kontrolach w czasie wykonywania lub usuwaniu elementów bezużytecznych.