POSIX MUTEX w C

„Zastosowanie Mutex jest metodą zapobiegania najczęściej stosowanym sytuacjom wyścigu. Mutex, który odnosi się do wzajemnego wykluczenia, zasadniczo daje nam blokadę martwą, która powstrzymuje kilku użytkowników przed jednoczesnym dostępem do i modyfikowania kluczowych danych. Ilekroć wiele lub więcej procesów stosuje ten sam proces, co ich medium do zakończenia przetwarzania, należy unikać impasu. Głównym przedmiotem dzisiejszej dyskusji będzie użycie funkcji POSIX MUTEX, aby uniknąć impasu z różnymi metodami z językiem C w Ubuntu 20.04 System. Przed zrobieniem czegoś z fragmentami kodu powinniśmy zainstalować kompilator „GCC”."

Przykład 01

Rozpoczniemy naszą pierwszą ilustrację funkcji POSIX MUTEX z potrzebnymi nagłówkami. Bez tych nagłówków nasz skrypt C nie będzie możliwy do operowania w sposób, w jaki tego chcemy. Pierwszy stdio.Nagłówek H jest odpowiedzialny za wykorzystanie regularnych wejść i wyjść w kodzie. Standardowy nagłówek „stdlib” jest odpowiedzialny za płynne użycie standardowych funkcji biblioteki w fragmencie kodu. Unistd.H Nagłówek jest koniecznością, aby napotkać problemy związane z unicodami. Oto biblioteka, aby wykorzystać zmienne i funkcje ciągów związane z ciągiem w języku C, i.mi., strunowy.H.

Wreszcie biblioteka jest „pthread.Nagłówek H ”, który jest koniecznością, gdy chcesz użyć wielowali w fragmentach. Ta biblioteka zawiera tworzenie wątków, łączenie wątków, blokowanie wątków, odblokowanie wątków i wiele innych funkcji związanych z wielofunkcyjnym.

#włączać
#włączać
#włączać
#włączać
#włączać

Po odrzuceniu niezbędnych nagłówków zainicjujemy 2 wątki za pomocą obiektu „pthread_t” z biblioteki wątku. Wartość „t” będzie używana jako identyfikator wątków w najbliższej przyszłości. Następnie zmienna liczb całkowita „I” jest inicjowana do 0, a zmienna „C” została zadeklarowana do zliczenia wątków. Obiekt zamka Mutex „ML” został wygenerowany za pomocą obiektu pthread_mutex_t. Oto funkcja wątku „T”, która zamyka i odblokuje wątek. Aby zablokować wątek wywołania, używamy funkcji pThread_Mutex_Lock () za pomocą zamka „ML”, zliczając numer wątku.

Instrukcje printf () są tutaj, aby powiedzieć nam o inicjalizacji i końca określonego wątku. W ramach inicjalizacji i na końcu funkcji wątku „T” jest zablokowana i nie można uzyskać do nich dostępu inne wątki. Ostatecznie funkcja pthread_mutex_unlock () jest używana do odblokowania określonego wątku i zapewnienia dostępu do innych wątków.

pthread_t t [2];
int i = 0;
int c;
pthread_mutex_lock (& ​​ml);
niepodpisany długi i = 0;
C += 1;
printf („inicjowany %d wątek… \ n”, c);
dla (i = 0; i<(0xFFFFFFFF); i++)
;
sen (5);
printf („Ended %d Wątek… \ n”, c);
sen (5);
pthread_mutex_unlock (& ​​ml);
powrót NULL;

Funkcja main () zaczyna się od instrukcji „jeśli”, która sprawdzała jakiś warunek. Używa funkcji pthread_mutex_init (), przekazując ją „ml” obiektu blokady i wartość zerową, aby zainicjować zamek mutx. Jeśli zwrócona wartość funkcji init () nie jest równa 0, instrukta. Tymczasem pętla while () używa warunku dla zmiennej „i”, która powinna być mniejsza niż 2. Jeśli jest mniej niż 2, wówczas funkcja Thread_Create () zostanie wywołana przez przekazanie identyfikatora wątku „T” jako wskaźnika i wskaźnika w kierunku funkcji wątku „T”. Jeśli wątek został pomyślnie utworzony, zwróciłby „0” do zmiennej „E”.

W przypadku, gdy zwróci inaczej niż 0, wydrukuje, i.mi., Korzystanie z funkcji Strerror i zwiększenie wartości zmiennej „i”. Ta funkcja jest odpowiedzialna za wywołanie funkcji wątku t dla dwóch różnych wątków. Funkcja pthread_join () używa identyfikatora wątku, aby dołączyć do nich z funkcją main (), a funkcja pthread_mutex_destroy () ma zniszczyć blokadę po wykonaniu wszystkich funkcji. Wrócenie do wiadomości main () zostanie wyświetlone na końcu tego programu po wykonaniu wątku.

int main ()
if (pthread_mutex_init (& ml, null) != 0)
printf („Nie udało się zainicjować Mutex Lock… \ n”);
zwrot 1;

podczas gdy ja<2)
int e = pthread_create (& t [i], null i t, null);
if (e != 0)
printf („Nie udało się utworzyć wątku: [%s]”, Strerror (e));
i ++;

pthread_join (t [0], null);
pthread_join (t [1], null);
pthread_mutex_destroy (& ml);
printf ("Hello! Wróciliśmy do głównej metody… \ n ”);
powrót 0;

Kompilujemy test.plik C z kompilatorem „GCC” i opcją -lpthread dla wykonania wątków. Wykonanie pokazuje, że pierwszy wątek ma dostęp do funkcji „t” i zablokowany.

Po uwolnieniu zamka z pierwszego wątku, a następnie dostęp do funkcji T został podany do drugiego wątku, a także został zablokowany i odblokowany.

Ostatecznie oba wątki zostały wykonane, a funkcja main () otrzymała kontrolę.

Przykład 02

Oto kolejny sposób, aby zademonstrować użycie POSIX MUTEX do zablokowania i odblokowania wątków. W ramach tego przykładu nie wymagamy unistd.h Nagłówek, więc nie będziemy go używać. W przeciwnym razie wszystkie nagłówki są tutaj, których użyliśmy w powyższym przykładzie. Obiekt pthread_mutex_t służy do utworzenia zamka Mutex „ML”. Metoda main () zaczyna się od inicjowania dwóch wątków, T1 i T2, używając obiektu pthread_t. Używa funkcji pthread_create () dwukrotnie do tworzenia wątków przez wywołanie funkcji T1 i.mi., T1 i T2. W tworzeniu wątków funkcja T1 i T2 została wykonana jeden po drugiej. Każda z tych funkcji jest nazywana funkcją testu (), przekazując 2 wartości ciągów jako parametry.

Funkcja testowa jest używana tutaj do zablokowania i odblokowania określonych wątków, które ją nazywają, i.mi., T1 i T2. Do blokowania wątków używana jest funkcja pthread_mutex_lock () i do odblokowywania używana jest funkcja pthread_mutex_unlock (), i.mi., Oba wykorzystują zamek „ML”. W procesie zamka i odblokowania instrukcje printf są używane z 5-sekundowym snem po każdym. Pierwsza metoda printf () wyświetli pierwszy argument przekazany do funkcji testowej, a druga metoda printf () wyświetli drugi argument string przekazany do funkcji testowej.

#włączać
#włączać
#włączać
#włączać
pthread_mutex_t ml;
void* test (char* p, char* q)
pthread_mutex_lock (& ​​ml);
printf („%s… \ n”, p);
sen (5);
printf („%s… \ n”, q);
sen (5);
pthread_mutex_unlock (& ​​ml);

void* t1 (void* z)
Test („zainicjowany”, „1. wątek”);
void* t2 (void* z)
Test („inicjowany”, „2. wątek”);
int main ()
pthread_t t1, t2;
pthread_create (& t1, null i t1, null);
pthread_create (& t2, null i t2, null);
while (1)
wyjście (0);

Podczas kompilacji pokaże ci ostrzeżenie, ale możesz go zignorować na chwilę.

Wykonanie skompilowanego kodu pokazuje, że pierwszy wątek został zainicjowany i otrzymał wszystkie zasoby funkcji testowej.

Po tym zamek został zwolniony, a drugi wątek otrzymał zasoby. Po drugim wątku musimy silnie wyjść z wykonania.

Wniosek

Koncepcja POSIX MUTEX jest krótko wyjaśniona, aby uniknąć impasu w programowaniu C. Dlatego zastosowaliśmy funkcje pthread_mutex_lock i pthread_mutex_unlock, aby to wykonać. Korzystając z tych funkcji w naszych fragmentach kodu, zapewniliśmy wykorzystanie zasobów dla jednego wątku.