pthread_cond_init(3)       Library Functions Manual       pthread_cond_init(3)

NUME
       pthread_cond_init, pthread_cond_signal, pthread_cond_broadcast,
       pthread_cond_wait, pthread_cond_timedwait, pthread_cond_destroy -
       opera<?>ii asupra condi<?>iilor

SINOPSIS
       #include <pthread.h>

       pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

       int pthread_cond_init(pthread_cond_t *cond,
                             pthread_condattr_t *cond_attr);
       int pthread_cond_signal(pthread_cond_t *cond);
       int pthread_cond_broadcast(pthread_cond_t *cond);
       int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
       int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
                             const struct timespec *abstime);
       int pthread_cond_destroy(pthread_cond_t *cond);

DESCRIERE
       O condi<?>ie (prescurtare de la ,,variabila de condi<?>ie") este un
       mecanism de sincronizare care permite firelor de execu<?>ie sa suspende
       execu<?>ia <?>i sa cedeze procesoarele pana cand este satisfacuta o
       anumita condi<?>ie (un predicat) privind datele partajate. Opera<?>iile
       de baza ale condi<?>iilor sunt: semnalizarea condi<?>iei (cand
       predicatul devine adevarat) <?>i a<?>teptarea condi<?>iei, suspendand
       execu<?>ia firului pana cand un alt fir semnalizeaza condi<?>ia.

       O variabila de condi<?>ie trebuie sa fie intotdeauna asociata cu un
       mutex, pentru a evita condi<?>ia de ,,competi<?>ie pentru ob<?>inerea
       de date" in care un fir se pregate<?>te sa a<?>tepte pe o variabila de
       condi<?>ie <?>i un alt fir semnalizeaza condi<?>ia chiar inainte ca
       primul fir sa a<?>tepte efectiv pe ea.

       pthread_cond_init() ini<?>ializeaza variabila de condi<?>ie cond,
       utilizand atributele de condi<?>ie specificate in cond_attr sau
       atributele implicite daca cond_attr este NULL. Implementarea
       ,,LinuxThreads" nu accepta atribute pentru condi<?>ii, prin urmare
       parametrul cond_attr este de fapt ignorat.

       Variabilele de tip pthread_cond_t pot fi, de asemenea, ini<?>ializate
       static, utilizand constanta PTHREAD_COND_INITIALIZER.

       pthread_cond_signal() reporne<?>te unul dintre firele care a<?>teapta
       variabila de condi<?>ie cond. In cazul in care niciun fir de execu<?>ie
       nu a<?>teapta pe cond, nu se intampla nimic. In cazul in care mai multe
       fire a<?>teapta pe cond, se reporne<?>te exact unul dintre ele, dar nu
       se specifica care.

       pthread_cond_broadcast() reporne<?>te toate firele care a<?>teapta
       variabila de condi<?>ie cond. Nu se intampla nimic daca niciun fir de
       execu<?>ie nu a<?>teapta pe cond.

       pthread_cond_wait() deblocheaza atomic mutex (conform
       pthread_mutex_unlock()) <?>i a<?>teapta ca variabila de condi<?>ie cond
       sa fie semnalata. Execu<?>ia firului este suspendata <?>i nu consuma
       timp CPU pana cand variabila de condi<?>ie nu este semnalata. mutex
       trebuie sa fie blocata de firul apelant la intrarea in
       pthread_cond_wait(). Inainte de a reveni la firul apelant,
       pthread_cond_wait() recupereaza mutex (conform pthread_mutex_lock()).

       Deblocarea mutex-ului <?>i suspendarea pe variabila de condi<?>ie se
       face atomic. Astfel, daca toate firele achizi<?>ioneaza intotdeauna
       mutex-ul inainte de a semnaliza condi<?>ia, acest lucru garanteaza ca
       condi<?>ia nu poate fi semnalata (<?>i, prin urmare, ignorata) intre
       momentul in care un fir blocheaza mutex-ul <?>i momentul in care
       a<?>teapta pe variabila de condi<?>ie. A se vedea sec<?>iunea
       <<AVERTISMENTE>> de mai jos.

       pthread_cond_timedwait() deblocheaza atomic mutex <?>i a<?>teapta pe
       cond, la fel ca pthread_cond_wait, dar limiteaza <?>i durata
       a<?>teptarii. Daca cond nu a fost semnalata in intervalul de timp
       specificat de abstime, mutex-ul mutex este reacceptat din nou, iar
       pthread_cond_timedwait() returneaza eroarea ETIMEDOUT. Parametrul
       abstime specifica un timp absolut, cu aceea<?>i origine ca <?>i time(2)
       <?>i gettimeofday(2): un abstime de 0 corespunde la 00:00:00 GMT, 1
       ianuarie 1970.

       pthread_cond_destroy() distruge o variabila de condi<?>ie, eliberand
       resursele pe care le-ar putea con<?>ine. La intrarea in
       pthread_cond_destroy() nu trebuie sa existe fire de execu<?>ie care sa
       a<?>tepte variabila de condi<?>ie. In implementarea ,,LinuxThreads", nu
       exista resurse asociate variabilelor de condi<?>ie, astfel incat
       pthread_cond_destroy() nu face de fapt nimic, cu excep<?>ia verificarii
       faptului ca nu exista fire de execu<?>ie in a<?>teptare.

ANULARE
       pthread_cond_wait() <?>i pthread_cond_timedwait() sunt puncte de
       anulare. Daca un fir este anulat in timp ce este suspendat intr-una din
       aceste func<?>ii, firul i<?>i reia imediat execu<?>ia, apoi blocheaza
       din nou argumentul mutex la pthread_cond_wait() <?>i
       pthread_cond_timedwait() <?>i, in final, executa anularea. In
       consecin<?>a, gestionarii de cura<?>are sunt asigura<?>i ca mutex este
       blocat atunci cand sunt apela<?>i.

SIGURAN<?>A SEMNALELOR ASINCRONE
       Func<?>iile de condi<?>ie nu sunt sigure pentru semnale asincrone <?>i
       nu ar trebui sa fie apelate de la un gestionar de semnal. In special,
       apelarea pthread_cond_signal() sau pthread_cond_broadcast() de la un
       gestionar de semnal poate bloca firul apelant.

VALOAREA RETURNATA
       Toate func<?>iile de variabila de condi<?>ie returneaza 0 in caz de
       succes <?>i un cod de eroare diferit de zero in caz de eroare.

ERORI-IE<?>IRE
       pthread_cond_init(), pthread_cond_signal(), pthread_cond_broadcast()
       <?>i pthread_cond_wait() nu returneaza niciodata un cod de eroare.

       Func<?>ia pthread_cond_timedwait() returneaza urmatoarele coduri de
       eroare in caz de eroare:

              ETIMEDOUT
                     Variabila de condi<?>ie nu a fost semnalata pana la
                     expirarea timpului de a<?>teptare specificat de abstime.

       Func<?>ia pthread_cond_destroy returneaza urmatorul cod de eroare in
       caz de eroare:

              EBUSY  Unele fire sunt in prezent in a<?>teptare pe cond.

CONSULTA<?>I <?>I
       pthread_condattr_init(3), pthread_mutex_lock(3),
       pthread_mutex_unlock(3), gettimeofday(2), nanosleep(2).

AVERTISMENTE
       Implementarea func<?>iilor furnizate pana la glibc 2.25 utiliza un
       blocaj intern de date. Acest blocaj nu accepta mo<?>tenirea
       priorita<?>ii <?>i era supus unei inversari nelimitate a priorita<?>ii,
       vizibila intr-un sistem in timp real.

       Dupa rescrierea implementarii in glibc 2.25, utilizarea blocarii
       interne s-a modificat.  Blocarea interna este intotdeauna ob<?>inuta de
       func<?>iile de semnalizare pthread_cond_signal()  <?>i
       pthread_cond_broadcast().  Func<?>ia de a<?>teptare ob<?>ine blocarea
       daca procesul de a<?>teptare a fost intrerupt.  Intreruperea poate fi
       cauzata, de exemplu, de un timp de expirare specificat <?>i indicata de
       valoarea de eroare ETIMEDOUTA sau de un semnal primit, care este
       indicat de valoarea de eroare EINTR.

EXEMPLU
       Se considera doua variabile partajate x <?>i y, protejate de mutex-ul
       mut, <?>i o variabila de condi<?>ie cond care trebuie semnalata ori de
       cate ori x devine mai mare decat y.


              int x,y; pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER; pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

       A<?>teptarea pana cand x este mai mare decat y se efectueaza dupa cum
       urmeaza:


              pthread_mutex_lock(&mut); while (x <= y) {         pthread_cond_wait(&cond, &mut); } /* opereaza asupra lui x <?>i y */ pthread_mutex_unlock(&mut);

       Modificarile lui x <?>i y care pot face ca x sa devina mai mare decat y
       trebuie sa semnalizeze condi<?>ia, daca este necesar:


              pthread_mutex_lock(&mut); /* modificarea lui x <?>i y */ if (x > y) pthread_cond_broadcast(&cond); pthread_mutex_unlock(&mut);

       Daca se poate dovedi ca cel mult un singur fir in a<?>teptare trebuie
       sa fie trezit (de exemplu, daca exista doar doua fire care comunica
       prin x <?>i y), pthread_cond_signal() poate fi utilizat ca o
       alternativa pu<?>in mai eficienta la pthread_cond_broadcast(). In caz
       de indoiala, utiliza<?>i pthread_cond_broadcast().

       Pentru a a<?>tepta ca x sa devina mai mare decat y cu un timp de
       a<?>teptare de 5 secunde, face<?>i:


              struct timeval now; struct timespec timeout; int retcode;  pthread_mutex_lock(&mut); gettimeofday(&now); timeout.tv_sec = now.tv_sec + 5; timeout.tv_nsec = now.tv_usec * 1000; retcode = 0; while (x <= y && retcode != ETIMEDOUT) {         retcode = pthread_cond_timedwait(&cond, &mut, &timeout); } if (retcode == ETIMEDOUT) {         /* a avut loc terminarea timpului de a<?>teptare */ } else {         /* opereaza asupra lui x <?>i y */ } pthread_mutex_unlock(&mut);

TRADUCERE
       Traducerea in limba romana a acestui manual a fost facuta de Remus-
       Gabriel Chelu <remusgabriel.chelu@disroot.org>

       Aceasta traducere este documenta<?>ie gratuita; citi<?>i Licen<?>a
       publica generala GNU Versiunea 3
       <https://www.gnu.org/licenses/gpl-3.0.html> sau o versiune ulterioara
       cu privire la condi<?>ii privind drepturile de autor.  NU se asuma
       NICIO RESPONSABILITATE.

       Daca gasi<?>i erori in traducerea acestui manual, va rugam sa
       trimite<?>i un e-mail la <translation-team-ro@lists.sourceforge.net>.

Pagini de manual de Linux 6.18  22 martie 2026            pthread_cond_init(3)