C++ Blokada Mutex

C Blokada Mutex

C++ jest znany jako jeden z najszybszych języków programowania o dobrej wydajności, wysokiej precyzji i odpowiednim systemie zarządzania pamięcią. Ten język programowania obsługuje również współbieżne wykonywanie wielu wątków z udostępnianiem wielu zasobów między nimi. W wielowątkowości wątek wykonuje tylko operację odczytu, która nie powoduje żadnych problemów, ponieważ wątek nie ma wpływu na to, co robią w tym czasie inne wątki. Ale jeśli te wątki musiały dzielić zasoby między sobą, jeden wątek może w tym czasie zmodyfikować dane, co powoduje problem. Aby poradzić sobie z tym problemem, mamy „Mutex” C++, który uniemożliwia dostęp wielu zasobów do naszego kodu/obiektu, zapewniając synchronizację, która mówi, że dostęp do obiektu/kodu może być zapewniony tylko jednemu wątkowi na raz, aby wiele wątków nie mogło jednocześnie uzyskać dostępu do tego obiektu.

Procedura:

Dowiemy się, w jaki sposób możemy zablokować dostęp wielu wątków do obiektu w jednym czasie za pomocą blokady mutex. Porozmawiamy o składni blokady mutex, co to jest wielowątkowość i jak radzić sobie z problemami wynikającymi z wielowątkowości przy użyciu blokady mutex. Następnie weźmiemy przykład z wielowątkowością i zaimplementujemy na nich blokadę mutex.







Składnia:

Jeśli chcemy dowiedzieć się, jak możemy zaimplementować blokadę mutex, aby uniemożliwić dostęp wielu wątków jednocześnie do naszego obiektu lub kodu, możemy użyć następującej składni:



$ standardowe :: muteks mut_x

$mut_x. Zamek ( ) ;

Unieważnij func_name ( ) {

$ // kod, który chcemy ukryć przed wieloma wątkami, zostałby napisany tutaj

$mut_x. odblokowuje ( ) ;

}

Użyjemy teraz tej składni w fikcyjnym przykładzie i w pseudokodzie (którego nie możemy po prostu uruchomić tak, jak jest w edytorze kodu), aby poinformować Cię, jak dokładnie możemy użyć tej składni, jak wspomniano poniżej:



$ standardowe :: muteks mut_x

Unieważnij blok ( ) {

$mut_x. Zamek ( ) ;

$ standardowe :: Cout << 'Witam' ;

$mut_x. odblokowuje ( ) ;

}

Przykład:

W tym przykładzie spróbujmy najpierw utworzyć operację wielowątkową, a następnie otoczyć tę operację blokadą mutex i odblokowaniem, aby zapewnić synchronizację operacji z utworzonym kodem lub obiektem. Mutex zajmuje się warunkami wyścigowymi, które są wartościami dość nieprzewidywalnymi i zależą od przełączania wątków świadomych czasu. Aby zaimplementować przykład dla mutex, najpierw musimy zaimportować ważne i wymagane biblioteki z repozytoriów. Wymagane biblioteki to:





$ # włącz

$ # to

$ # włącz

Biblioteka „iostream” udostępnia nam funkcję wyświetlania danych jako Cout, odczytywania danych jako Cin i kończenia instrukcji jako endl. Korzystamy z biblioteki „wątków”, aby wykorzystać programy lub funkcje z wątków. Biblioteka „mutex” pozwala nam zaimplementować zarówno blokadę mutex, jak i odblokowanie w kodzie. Używamy „# include”, ponieważ pozwala to na wszystkie programy związane z biblioteką zawartą w kodzie.

Teraz, po wykonaniu poprzedniego kroku, definiujemy klasę mutex lub zmienną globalną dla mutexa za pomocą std. Następnie tworzymy funkcję blokującą i odblokowującą mutex, którą możemy później wywołać w kodzie. W tym przykładzie nazywamy tę funkcję blokiem. W ciele funkcji blokowej najpierw wywołujemy „mutex.lock()” i zaczynamy pisać logikę kodu.



Funkcja mutex.lock() odmawia innym wątkom dostępu do stworzonego przez nas obiektu lub kodu, dzięki czemu tylko jeden wątek może jednocześnie odczytać nasz obiekt. W logice uruchamiamy pętlę for, która działa na indeksie od 0 do 9. Wyświetlamy wartości w pętli. Po utworzeniu tej logiki w blokadzie mutex po zakończeniu jej działania lub wyjściu z logiki, wywołujemy metodę „mutex.unlock()”. To wywołanie metody pozwala nam odblokować utworzony obiekt z blokady mutex, ponieważ dostęp obiektu do jednego wątku był zapewniony wcześniej i gdy operacja na tym obiekcie jest wykonywana przez jeden wątek na raz. Chcemy teraz, aby inne wątki również miały dostęp do tego obiektu lub kodu. W przeciwnym razie nasz kod porusza się w sytuacji „zakleszczenia”, co powoduje, że utworzony obiekt z muteksem na zawsze pozostanie w sytuacji zablokowanej i żaden inny wątek nie będzie w stanie uzyskać dostępu do tego obiektu. W związku z tym niekompletna operacja jest nadal wykonywana. Następnie wychodzimy z funkcji bloku i przechodzimy do głównego.

Zasadniczo po prostu wyświetlamy nasz utworzony muteks, tworząc trzy wątki za pomocą „std :: thread thread_name (wywołując już utworzoną funkcję blokową, w której utworzyliśmy mutex)” o nazwach thread1, thread2 i thread3, itd. W ten sposób powstają trzy wątki. Następnie łączymy te trzy wątki, aby były wykonywane jednocześnie, wywołując „nazwa_wątku”. połącz ()”. A potem zwracamy wartość równą zero. Wspomniane wcześniej wyjaśnienie przykładu jest zaimplementowane w postaci kodu, który można przedstawić na poniższym rysunku:

Na wyjściu kodu możemy zobaczyć wykonanie i wyświetlenie wszystkich trzech wątków jeden po drugim. Widzimy nawet, czy nasza aplikacja należy do kategorii wielowątkowości. Mimo to żaden z wątków nie nadpisał ani nie zmodyfikował danych i nie udostępnił zmodyfikowanego zasobu z powodu implementacji muteksu „bloku funkcyjnego”.

Wniosek

Ten przewodnik zawiera szczegółowe wyjaśnienie koncepcji funkcji mutex używanej w C++. Omówiliśmy czym są aplikacje wielowątkowe, jakie problemy musimy napotkać w aplikacjach wielowątkowych i dlaczego musimy zaimplementować mutex dla aplikacji wielowątkowych. Następnie omówiliśmy składnię muteksu z fikcyjnym przykładem przy użyciu pseudokodu. Następnie zaimplementowaliśmy kompletny przykład na aplikacjach wielowątkowych z mutexem w Visual Studio C++.