Pthread_cond_wait -funksjonen i C

I dagens emne vil vi diskutere PTHREAD_COND_WAIT () -funksjonen. Dette som koordinerer mellom tråder, kalles tilstandsvariabler. Før vi diskuterer om denne funksjonen, må vi vite om tilstandsvariablene.

Det er en type synkronisering som finnes mellom tråder som kalles låser. I dette tilfellet trenger tråden gjensidig utelukkelse. Det krever en tråd for å utføre om gangen. Deretter, også hverandre som kreves når flere tråder er samhandlet. De er - venter og signaliserer. En tråd vil vente til annen tråd er ferdig med jobben. Etter å ha fullført utførelsen av denne tråden, kan den ventende tråden utføres i prosessoren. For en slik type trådsynkronisering trenger vi en annen teknikk, kalt opptatt med å vente på noen variabler. For dette trenger vi en ny synkronisering primitive kalt tilstandsvariabler.

Dette trådkonseptet er tilgjengelig i forskjellige operativsystem. Men vi vil gå til navnet, tilstandsvariabler som brukes som Pthread -bibliotek i Linux -operativsystem

Funksjonen pthread_cond_wait () er en komponent av vent. Denne funksjonen som standard utfører låsingen.

Programmering eksempel-1:

I dette programmeringseksemplet vil vi se hvordan denne funksjonen utfører:

#inkludere
#inkludere
#inkludere
#inkludere
#inkludere
pthread_mutex_t m = pthread_mutex_initializer; // erklære tilstandsvariabelen.
pthread_cond_t c = pthread_cond_initializer;
int gjort = 0;
void thr_exit ()

pthread_mutex_lock (& ​​m);
gjort = 1;
pthread_cond_signal (& c);
pthread_mutex_unlock (& ​​m);

void *barn (ugyldig *arg) // barneprosess utfører.

printf ("barn \ n");
thr_exit ();
return null;

void thr_join ()

pthread_mutex_lock (& ​​m);
mens (gjort == 0)
pthread_cond_wait (& c, & m); // Ring funksjonen i Thr_join () -funksjonen.
pthread_mutex_unlock (& ​​m);

int main (int argc, char* argv [])
printf ("Foreldre: begynn \ n");
pthread_tp;
pthread_create (& p, null, barn, null); // initialisere tråden.
thr_join ();
printf ("Foreldre: slutt \ n");
retur 0;

Produksjon:

Forklaring

I dette programmeringseksemplet eksisterer det to prosesser som kalles en overordnet tråd og en barnetråd. Her vil foreldre vente på barnet. Etter å ha fullført utførelsen av barneprosessen, starter foreldrene utførelsen.

For innsiden () oppretter vi foreldre- og barnetråden. Barntråd utfører funksjonen som heter Child (). Deretter kaller foreldretråden funksjonen bli med. Denne sammenføyningen () sjekker i utgangspunktet at barnet er ferdig. Ellers vil det vente ved å bruke Pthread_Cond_wait () -funksjonen. Når barnet løper, kaller det avkjørselen (). Når barnets henrettelse er ferdig, vil verdien av variabel utført å være 1. Deretter kaller det signalet på tilstandsvariable. Etter det starter utførelsen av foreldretråden.

Vent og signalsyntaks:

void thr_exit ()

gjort = 1;
pthread_cond_signal (& c);

void thr_join ()

if (gjort == 0)
pthread_cond_wait (& c);

Hva skjer hvis vi ikke får en lås? Det vil forekomme en løpsbetingelse - savnet vekker.

• Foreldreprosess har ingenting for utførelse og å gå til tomgangstilstand, for den saken kan oppstå.
• Når Child utfører sin kode og oppnådde utførelsen, signaliserer den, men ingen sover ennå.
• Foreldre startet nå utførelsen fra der den var ferdig og må ventet i en bestemt periode.
• For denne ventetiden må du huske på at tråden ikke er suspendert i en lengre periode. Den må åpnes låsen sin.

Programmering Eksempel-2:

I dette programmeringseksemplet vil vi se en annen bruk av pthread_cond_wait fuction.

#inkludere
#inkludere
#inkludere
#inkludere
#inkludere
PTHREAD_MUTEX_TMUTEXFUEL;
pthread_cond_tcondfuel; // Opprette tilstandsvariabelen.
int drivstoff = 0;
void* Fueling (void* arg)
for (int i = 0; i < 5; i++)
pthread_mutex_lock (& ​​mutexfuel);
drivstoff += 15;
printf ("Fikk drivstoff ... %d \ n", drivstoff);
pthread_mutex_unlock (& ​​mutexfuel);
pthread_cond_signal (& condfuel);
søvn (1);


void* kjøretøy (void* arg)
pthread_mutex_lock (& ​​mutexfuel);
mens (drivstoff < 40)
printf ("null drivstoff. Venter… \ n ");
pthread_cond_wait (& condfuel, & mutexfuel);
// Tilsvarende:
// pthread_mutex_unlock (& ​​mutexfuel);
// Vent på signal på Condfuel
// pthread_mutex_lock (& ​​mutexfuel);

Drivstoff -= 40;
printf ("Drivstoff samlet nå til venstre: %d \ n", drivstoff);
pthread_mutex_unlock (& ​​mutexfuel);

int main (int argc, char* argv [])
pthread_ta [2];
pthread_mutex_init (& mutexfuel, null);
pthread_cond_init (& condfuel, null);
for (int i = 0; i < 2 ; i++ )
if (i == 1)
if (pthread_create (& a [i], null, & drivstoff, null) != 0)
Perror ("Kunne ikke lage tråd");

annet
if (pthread_create (& a [i], null, & kjøretøy, null) != 0)
Perror ("Kunne ikke lage tråd");



for (int i = 0; i < 2 ; i++ )
if (pthread_join (a [i], null) != 0)
Perror ("Kunne ikke bli med i tråden");


pthread_mutex_destroy (& mutexfuel);
pthread_cond_destroy (& condfuel); // ødelegger trådene.
retur 0;

Produksjon:

Forklaring

Her vil vi se anvendelsen av Pthread_Cond_wait () -funksjonen. Det er som når noen vil fylle drivstoffet hans. Han må vente til bilen hans blir fylt opp med drivstoff. For dette lager vi to tråder. En for å fylle drivstoffet i bilen og for bilen. Vi vil definere to funksjoner. Den ene er Fueling () -funksjon som bestemmer når du skal fylle bilen med drivstoff og en annen er kjøretøy () -funksjonen for å få drivstoff. Fyren som vil fylle drivstoffet i bilen hans, må vente til drivstoffet er fylt opp.

Inne i hovedfunksjonen () vil vi lage to tråder for drivstoff () og for kjøretøy () -funksjon. Nå vil vi lage en tilstandsvariabel for å vente på tilstand. For dette vil vi se utdataene. Når funksjoner fullfører utførelsen, vil vi ødelegge disse trådene.

Konklusjon

Pthread_cond_wait () -funksjonen varsler når vi har gjort et program ved hjelp av flere tråder. Denne funksjonen vil lage noen tilstandsvariabler for å håndtere disse trådene. Egentlig avhenger egenskapene til denne funksjonen helt av prinsippet om Vent og signalisere teori.