C ++ Mutex Lock

C ++ jest znany jako jeden z najszybszych języków programowania o dobrej wydajności, wysokiej precyzji i odpowiedniego systemu zarządzania pamięcią. Ten język programowania obsługuje również jednoczesne wykonywanie wielu wątków z dzieleniem się wieloma zasobami między nimi. Podczas wielowy, wątek ma na celu wykonywanie operacji odczytu, która nie ma problemów, ponieważ wątek nie ma wpływu na to, co robią inne wątki. Ale jeśli te wątki musiały udostępnić między nimi zasoby, jeden wątek może zmodyfikować dane w tym czasie, co czyni problem. Aby poradzić sobie z tym problemem, mamy „mutek” C ++, który zapobiega dostępowi wielu zasobów do naszego kodu/obiektu, zapewniając synchronizację, która stwierdza, że ​​dostęp do obiektu/kodu może być dostarczany tylko do jednego wątku jednocześnie, jednocześnie, tak, aby wiele wątków nie miało dostępu jednocześnie w tym obiekcie.

Procedura:

Dowiemy się, jak możemy zatrzymać dostęp do wielu wątków do obiektu w jednym czasie za pomocą Mutex Lock. Porozmawiamy o składni Mutex Lock, co to jest wiele wątków i jak możemy poradzić sobie z problemami spowodowanymi wieloma wątkami za pomocą zamka Mutex. Następnie weźmiemy przykład wielu wątków i zaimplementujemy ich zamek Mutex.

Składnia:

Jeśli chcemy dowiedzieć się, w jaki sposób możemy zaimplementować blokadę Mutex, abyśmy mogli zapobiec dostępowi wielu wątków jednocześnie do naszego obiektu lub kodu, możemy użyć następującej składni:

$ std :: mutex mut_x
$ MUT_X. zamek ();
Void func_name ()
$ // kod, który chcemy ukryć przed wieloma wątkami, zostanie napisany tutaj
$ MUT_X. odblokuj ();

Użyjemy teraz tej składni na przykładowym przykładzie i w pseudo kodzie (którego nie możemy po prostu uruchomić, tak jak w edytorze kodu), aby poinformować Cię, jak możemy dokładnie użyć tej składni, jak wspomniano następująco:

$ std :: mutex mut_x
Void block ()
$ MUT_X. zamek ();
$ std :: cout << “hello”;
$ MUT_X. odblokuj ();

Przykład:

W tym przykładzie spróbujmy najpierw utworzyć działanie wielowy, a następnie otajem tę operację za pomocą Mutex Lock and odblokuj, aby zapewnić synchronizację działania z utworzonym kodem lub obiektem. Mutex zajmuje się warunkami rasowymi, które są wartościami, które są dość nieprzewidywalne i są zależne od przełączania wątków, które są świadome czasu. Aby wdrożyć przykład MutEx, najpierw musimy zaimportować ważne i wymagane biblioteki z repozytoriów. Wymagane biblioteki to:

$ # obejmują
$ # obejmują
$ # obejmują

Biblioteka „iostream” zapewnia nam funkcję do wyświetlania danych jako cout, odczytu danych jako CIN i zakończenia instrukcji jako ENDL. Używamy biblioteki „wątków” do korzystania z programów lub funkcji z wątków. Biblioteka „Mutex” pozwala nam zaimplementować zarówno blokadę Mutex, jak i odblokować w kodzie. Używamy „# obejmują”, ponieważ pozwala to na wszystkie programy związane z biblioteką zawartą w kodzie.

Teraz, po zakończeniu poprzedniego kroku, definiujemy klasę Mutex lub zmienną globalną dla Mutex za pomocą STD. Następnie tworzymy funkcję Mutex Lock i odblokowujemy, którą moglibyśmy później wywołać w kodzie. W tym przykładzie nazywamy tę funkcję jako blok. W ciele funkcji bloku najpierw nazywamy „mutex.lock () ”i zacznij pisać logikę kodu.

Mutex.lock () zaprzecza dostępu do innych wątków, aby dotrzeć do naszego utworzonego obiektu lub kodu, aby tylko jeden wątek mógł odczytać nasz obiekt jednocześnie. W logice uruchamiamy pętlę dla indeksu od 0 do 9. Wyświetlamy wartości w pętli. Po utworzeniu logiki w zamku Mutex po zakończeniu jej działania lub po wyjściu z logiki nazywamy „Mutex.Metoda odblokuj () ”. To wywołanie metody pozwala nam odblokować utworzony obiekt z Mutex Lock, ponieważ dostęp obiektu do jednego wątku został podany wcześniej, a gdy operacja na tym obiekcie jest wykonywana przez jeden wątek jednocześnie. Teraz chcemy, aby inne wątki również uzyskuły dostęp do tego obiektu lub kodu. W przeciwnym razie nasz kod porusza się w sytuacji „zakleszczenia”, która powoduje, że utworzony obiekt z mutexem pozostaje w zamkniętej sytuacji na zawsze i żaden inny wątek nie byłby w stanie uzyskać dostępu do tego obiektu. Stąd niekompletna operacja utrzymuje się w realizacji. Następnie wychodzimy z funkcji bloku i przechodzimy do głównej.

W głównej po prostu wyświetlamy nasz utworzony Mutex, tworząc trzy wątki za pomocą „std :: Thread_name (wywoływanie już utworzonej funkcji blokowej, w której utworzyliśmy mutex)” z nazwami Thread1, Thread2 i Thread3 itp. W ten sposób tworzone są trzy wątki. Następnie dołączamy do tych trzech wątków, które zostaną wykonane jednocześnie, wywołując „Nazwa_wątna. Metoda dołączania () ”. A następnie zwracamy wartość równą zero. Wspomniane wcześniej wyjaśnienie przykładu jest zaimplementowane w postaci kodu, który można pokazać na poniższym rysunku:

W wyjściu kodu możemy zobaczyć wykonanie i wyświetlanie wszystkich trzech wątków jeden po drugim. Widzimy nawet, jeśli nasza aplikacja jest zgodna z kategorią wielowy. Mimo to żaden z wątków nie zastąpił ani nie zmodyfikował danych i nie udostępnił zmodyfikowanego zasobu z powodu wdrożenia muteksu „bloku funkcyjnego”.

Wniosek

Ten przewodnik zawiera szczegółowe wyjaśnienie koncepcji funkcji muteksu zastosowanej w C++. Omówiliśmy, jakie są aplikacje wielowątkowe, jakie problemy musimy napotkać w aplikacjach wielowy i dlaczego musimy zaimplementować MUTEX dla aplikacji wielowy. Następnie omówiliśmy składnię dla mutex z przykładem manekina przy użyciu pseudo-kodu. Następnie zaimplementowaliśmy kompletny przykład aplikacji wielowy z Mutex w C ++ Visual Studio.