Funkcja pthread_cond_wait w c

W dzisiejszym temacie omówimy funkcję pthread_cond_wait (). To, które współrzędne między wątkami nazywa się zmiennymi warunku. Przed omówieniem tej funkcji musimy wiedzieć o zmiennych warunków.

Istnieje jeden rodzaj synchronizacji, który istnieje między wątkami zwanymi zamkami. W tym przypadku wątek wymaga wzajemnego wykluczenia. Wymaga wykonania jednego wątku na raz. Następnie także jeden wspólny wzór wymagany po oddziaływaniu wielu wątków. Są - czekając i sygnalizacja. Jeden wątek będzie poczekać, aż drugi wątek zakończy swoją pracę. Po zakończeniu wykonania tego wątku wątek oczekiwania może wykonać w procesorze. Do tego rodzaju synchronizacji wątków potrzebujemy innej techniki, zwanej zajęty czekanie na niektóre zmienne. W tym celu potrzebujemy nowej prymitywnej synchronizacji zwanej zmiennymi warunku.

Ta koncepcja wątku jest dostępna w innym systemie operacyjnym. Ale przejdziemy do nazwy, zmiennych warunków, które są stosowane jako biblioteka pthread w systemie operacyjnym Linux

Funkcja pthread_cond_wait () jest składnikiem oczekiwania. Ta funkcja domyślnie wykonuje akcję odblokowywania.

Przykład programowania 1:

W tym przykładzie programowania zobaczymy, jak ta funkcja wykonuje:

#włączać
#włączać
#włączać
#włączać
#włączać
pthread_mutex_t m = pThread_Mutex_Initializer; // deklarowanie zmiennej warunku.
pthread_cond_t c = pthread_cond_initializer;
int Done = 0;
void thr_exit ()

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

void *child (void *arg) // proces dzieci wykonuje.

printf („dziecko \ n”);
thr_exit ();
powrót NULL;

void thr_join ()

pthread_mutex_lock (& ​​m);
while (gotowe == 0)
pthread_cond_wait (& c, & m); // wywołać funkcję w funkcji thr_join ().
pthread_mutex_unlock (& ​​m);

int main (int argc, char* argv [])
printf („rodzic: początek \ n”);
pthread_tp;
pthread_create (& p, null, dziecko, null); // Inicjowanie wątku.
thr_join ();
printf („rodzic: end \ n”);
powrót 0;

Wyjście:

Wyjaśnienie

W tym przykładzie programowania istnieją dwa procesy zwane wątkiem nadrzędnym i wątkiem dziecięcym. Tutaj rodzic chce czekać na dziecko. Po zakończeniu procesu dziecięcego, rodzic rozpoczyna wykonanie.

Dla wnętrza main () tworzymy wątek rodzica i dziecięcego. Child Wątek wykonuje funkcję o nazwie dziecko (). Następnie wątek nadrzędny wywołuje połączenie funkcji. To połączenie () zasadniczo sprawdza, czy dziecko jest gotowe. W przeciwnym razie będzie czekać, używając funkcji pthread_cond_wait (). Kiedy dziecko będzie działać, nazywa Exit (). Po zakończeniu wykonania dziecka wartość zmiennej wyniesie 1. Następnie wywołuje sygnał w zmiennej warunku. Następnie rozpocznie się wykonanie wątku nadrzędnego.

Poczekaj i sygnał składnia:

void thr_exit ()

Done = 1;
pthread_cond_signal (& c);

void thr_join ()

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

Co się stanie, jeśli nie dostaniemy zamka? Nastąpi warunek wyścigu - nieudany budzenie.

• Proces nadrzędny nie ma nic do wykonywania i przechodzenia na bezczynność, ponieważ może nastąpić przerwa w sprawie.
• Kiedy dziecko wykonuje swój kod i wykonuje jego wykonanie, to sygnalizuje, ale nikt jeszcze nie śpi.
• rodzic ponownie uruchomił swój wykonanie z miejsca, w którym się skończył i musi być czekany na określony okres.
• W przypadku tej funkcji oczekiwania musi pamiętać, że wątek nie jest zawieszony na dłuższy czas. Należy go otworzyć.

PROGRAMOWANIE Przykład-2:

W tym przykładzie programowania zobaczymy kolejne zastosowanie fukcji pthread_cond_wait.

#włączać
#włączać
#włączać
#włączać
#włączać
pthread_mutex_tmuxfuel;
pthread_cond_tcondfuel; // tworzenie zmiennej warunku.
int paliwo = 0;
void* tankowanie (void* arg)
dla (int i = 0; i < 5; i++)
pThread_Mutex_Lock (& ​​mutexfuel);
paliwo += 15;
printf („dostał paliwo… %d \ n”, paliwo);
pthread_mutex_unlock (i mutexfuel);
pthread_cond_signal (& Condfuel);
sen (1);


void* pojazd (void* arg)
pThread_Mutex_Lock (& ​​mutexfuel);
While (paliwo < 40)
printf ("zero paliwa. Czekam… \ n ”);
pthread_cond_wait (& Condfuel i Mutexfuel);
// Równoważny:
// pthread_mutex_unlock (& ​​mutexfuel);
// Poczekaj na sygnał na Condfuel
// pthread_mutex_lock (& ​​mutexfuel);

paliwo -= 40;
printf („Zebrane paliwo już po lewej: %d \ n”, paliwo);
pthread_mutex_unlock (i mutexfuel);

int main (int argc, char* argv [])
pthread_ta [2];
pthread_mutex_init (i mutexfuel, null);
pthread_cond_init (& Condfuel, NULL);
dla (int i = 0; i < 2 ; i++ )
if (i == 1)
if (pthread_create (& a [i], null i tankowanie, null) != 0)
Perror („Nie udało się utworzyć wątku”);

w przeciwnym razie
if (pthread_create (& a [i], null i pojazd, null) != 0)
Perror („Nie udało się utworzyć wątku”);



dla (int i = 0; i < 2 ; i++ )
if (pthread_join ([i], null) != 0)
Perror („Nie udało się dołączyć do wątku”);


pThread_Mutex_Destroy (& mutexfuel);
pthread_cond_destroy (& Condfuel); // niszczenie wątków.
powrót 0;

Wyjście:

Wyjaśnienie

Tutaj zobaczymy zastosowanie funkcji pthread_cond_wait (). To tak, jak gdy ktoś chce wypełnić paliwo, jego samochód. Musi poczekać, aż jego samochód zostanie wypełniony paliwem. W tym celu tworzymy dwa wątki. Jeden do napełniania paliwa samochodem i do samochodu. Zdefiniujemy dwie funkcje. Jedna to funkcja Tuele (), która określa, kiedy napełnić samochód paliwem, a druga to funkcja pojazdu (), aby uzyskać paliwo. Facet, który chce wypełnić paliwo w swoim samochodzie, musi poczekać, aż paliwo się wypełni.

Wewnątrz funkcji main () utworzymy dwa wątki do funkcji tankowania () i do pojazdu (). Teraz utworzymy zmienną warunku, aby czekać na stan. W tym celu zobaczymy wyjście. Kiedy funkcje zakończą ich wykonanie, zniszczymy te wątki.

Wniosek

Funkcja pthread_cond_wait () powiadamia, kiedy wykonaliśmy jakiś program za pomocą wielu wątków. Ta funkcja stworzy pewne zmienne warunku, aby obsłużyć te wątki. W rzeczywistości cechy tej funkcji całkowicie zależy od zasady Poczekaj i sygnalizuj teoria.