Posix mutex i C

“Bruken av Mutex er metoden for å forhindre rasesituasjoner som brukes hyppigst. Mutex, som refererer til gjensidig utelukkelse, gir oss i det vesentlige en deadbolt -lås som hindrer flere brukere fra å samtidig få tilgang til og endre de avgjørende dataene. Hver gang flere eller flere prosesser bruker samme prosess som deres medium for å fullføre behandlingen, må deadlock unngås. Hovedfaget for dagens diskusjon vil være å bruke POSIX Mutex -funksjonen for å unngå dødvakt med forskjellige metoder med C -språk i Ubuntu 20.04 System. Før vi gjør noe med kodebitene dine, bør vi installere “GCC” -kompilatoren.”

Eksempel 01

Vi kommer til å starte vår første illustrasjon av Posix Mutex -funksjoner med de nødvendige overskriftene. Uten disse overskriftene vil ikke vårt manus av C fungere som vi vil ha det. Den første stdio.H Header er ansvarlig for bruk av vanlige innganger og utganger i koden. Standard "stdlib" -overskrift er ansvarlig for jevn bruk av standard bibliotekfunksjoner i kodebiten. Unistd.H header er et must for å møte problemer relatert til unicodes. Her kommer biblioteket for å bruke strengvariabler og funksjoner relatert til streng på C -språk, i.e., streng.h.

Endelig er biblioteket “Pthread.H ”-overskrift som er et must når du vil bruke multithreading i utdragene dine. Dette biblioteket inkluderer trådoppretting, trådkobling, trådlås, trådlås opp og mange andre funksjoner relatert til multithreading.

#inkludere
#inkludere
#inkludere
#inkludere
#inkludere

Etter å ha støpt av de nødvendige overskriftene, skal vi initialisere 2 tråder ved å bruke "pthread_t" -objektet fra trådens bibliotek. Verdien “T” vil bli brukt som tråd -ID i nær fremtid. Deretter initialiseres en heltallvariabel "I" til 0, og variabel “C” ble erklært for å telle trådene. MUTEX LOCK -objektet “ML” er blitt generert ved hjelp av PTHREAD_MUTEX_T -objektet. Her kommer trådfunksjonen “T”, som kommer til å låse og låse opp tråden. For å låse den anropende tråden bruker vi PTHREAD_MUTEX_LOCK () -funksjonen ved hjelp av "ML" -låsen mens vi teller trådnummeret.

Utskrift () uttalelser er her for å fortelle oss om initialiseringen og enden av en spesifikk tråd. Innen initialisering og slutt er trådfunksjonen “T” låst og kan ikke nås av andre tråder. Til slutt brukes Pthread_Mutex_unlock () -funksjonen for å låse opp den spesifikke tråden og gi tilgang til andre tråder.

pthread_t t [2];
int i = 0;
int c;
pthread_mutex_lock (& ​​ml);
usignert lang i = 0;
C += 1;
printf ("initiert %d tråd ... \ n", c);
for (i = 0; i<(0xFFFFFFFF); i++)
;
søvn (5);
printf ("endte %d tråd ... \ n", c);
søvn (5);
pthread_mutex_unlock (& ​​ml);
return null;

Main () -funksjonen starter fra "hvis" -uttalelsen som har sjekket noen tilstand. Den bruker Pthread_Mutex_init () -funksjonen ved å passere den “ML” låsobjekt og nullverdi for å initialisere mutex -låsen. Hvis init () -funksjonens returnerte verdi ikke er lik 0, vil PRINTF () -klæringen vise at Mutex -låsen ikke ble initialisert på grunn av noen problemer. I mellomtiden bruker mens () sløyfen tilstanden for variabel "i", som skal være mindre enn 2. Hvis det er mindre enn 2, vil funksjonen Thread_Create () bli kalt ved å passere tråd -ID “T” som peker og peker mot “T” trådfunksjonen. Hvis tråden ble opprettet med hell, ville den returnere “0” til “E” -variabelen.

I tilfelle hvis den kommer tilbake annet enn 0, vil den skrive ut en, jeg.e., Bruke strekkfunksjonen og øke verdien av en variabel “Jeg”. Denne funksjonen er ansvarlig for å kalle trådfunksjonen T for to forskjellige tråder. Pthread_join () -funksjonen bruker tråd -ID for å bli med dem med main () -funksjonen, og PTHREAD_MUTEX_DESTROY () -funksjonen er her for å ødelegge låsen etter at alle funksjonene er utført. Flytting tilbake til en Main () -melding vises på slutten av dette programmet etter trådutførelser.

int main ()
if (pthread_mutex_init (& ml, null) != 0)
printf ("Kunne ikke initialisere mutex -lås ... \ n");
retur 1;

mens jeg<2)
int e = pthread_create (& t [i], null, & t, null);
hvis (e != 0)
printf ("Kunne ikke opprette tråd: [%s]", strerror (e));
i ++;

pthread_join (t [0], null);
pthread_join (t [1], null);
pthread_mutex_destroy (& ml);
printf ("Hei! Vi er tilbake i hovedmetoden ... \ n ");
retur 0;

Vi sammenstiller testen.C -fil med “GCC” -kompilatoren og alternativet -Lpthread for tråder utførelse. Utførelsen viser at den første tråden fikk tilgang til “T” -funksjonen og låst.

Etter at låsen ble frigjort fra den første tråden, ble tilgang til T -funksjonen gitt til den andre tråden, og den ble låst og låst opp også.

Til slutt ble begge trådene utført, og hovedfunksjonen () fikk tilbake kontrollen.

Eksempel 02

Her kommer en annen måte å demonstrere bruken av Posix Mutex for å låse og låse opp trådene. Innenfor dette eksemplet krever vi ikke Unistd.H header, så vi kommer ikke til å bruke den. Ellers er alle overskriftene her, som vi brukte i eksemplet ovenfor. Pthread_mutex_t -objektet brukes til å lage en mutex -lås “ML”. Main () -metoden starter med å initialisere to tråder, T1 og T2, ved å bruke Pthread_T -objektet. Den bruker Pthread_Create () -funksjonen to ganger for å lage tråder ved å kalle funksjoner T1 og T2 ved å passere dem trådinitialiserings -ID -er som pekere, i.e., T1 og T2. På trådoppretting ble T1- og T2 -funksjonen utført etter hverandre. Hver av disse funksjonene kalles test () -funksjonen ved å passere 2 strengverdier som parametere.

Testfunksjonen brukes her for å låse og låse opp spesifikke tråder som kaller den, i.e., T1 og T2. For å låse trådene brukes PTHREAD_MUTEX_LOCK () -funksjonen, og for å låse opp, brukes PTHREAD_MUTEX_UNLOCK () -funksjonen, i.e., Begge bruker "ML" mutex -låsen. Innenfor lås- og låsingsprosessen brukes Printf-setningene med 5 sekunders søvn etter hver. Den første printf () -metoden vil vise det første argumentet som er gitt til testfunksjonen, og den andre printf () -metoden vil vise det andre strengargumentet som er gitt til testfunksjonen.

#inkludere
#inkludere
#inkludere
#inkludere
pthread_mutex_t ml;
void* test (char* p, char* q)
pthread_mutex_lock (& ​​ml);
printf ("%s ... \ n", p);
søvn (5);
printf ("%s ... \ n", q);
søvn (5);
pthread_mutex_unlock (& ​​ml);

void* t1 (void* z)
Test ("initiert", "1. tråd");
void* t2 (void* z)
Test ("initiert", "2. tråd");
int main ()
pthread_t t1, t2;
pthread_create (& t1, null, & t1, null);
pthread_create (& t2, null, & t2, null);
mens (1)
Avslutt (0);

Når du sammenstiller, vil det vise deg en advarsel, men du kan ignorere det et øyeblikk.

Utførelsen av den kompilerte koden viser at den første tråden ble initiert og fikk alle ressursene i testfunksjonen.

Etter dette ble låsen løslatt, og den andre tråden fikk ressursene. Etter den andre tråden må vi avslutte utførelsen kraftig.

Konklusjon

Posix Mutex -konseptet blir kort forklart for å unngå dødvakt i C -programmering. Derfor har vi ansatt pthread_mutex_lock og pthread_mutex_unlock -funksjonene for å utføre det. Ved å bruke disse funksjonene i kodebitene våre, har vi sikret bruk av ressurser for en tråd om gangen.