.\" -*- coding: UTF-8 -*- .\" Copyright, Xavier Leroy .\" Copyright 2023, Alejandro Colomar .\" .\" SPDX-License-Identifier: Linux-man-pages-copyleft .\" .\"******************************************************************* .\" .\" This file was generated with po4a. Translate the source file. .\" .\"******************************************************************* .TH pthread_cond_init 3 "16 iunie 2024" "Pagini de manual de Linux 6.9.1" . . .SH NUME pthread_cond_init, pthread_cond_signal, pthread_cond_broadcast, pthread_cond_wait, pthread_cond_timedwait, pthread_cond_destroy \- operații asupra condițiilor . . .SH SINOPSIS .nf \fB#include \fP .P \fBpthread_cond_t \fP\fIcond\fP\fB = PTHREAD_COND_INITIALIZER;\fP .P \fBint pthread_cond_init(pthread_cond_t *\fP\fIcond\fP\fB,\fP \fB pthread_condattr_t *\fP\fIcond_attr\fP\fB);\fP \fBint pthread_cond_signal(pthread_cond_t *\fP\fIcond\fP\fB);\fP \fBint pthread_cond_broadcast(pthread_cond_t *\fP\fIcond\fP\fB);\fP \fBint pthread_cond_wait(pthread_cond_t *\fP\fIcond\fP\fB, pthread_mutex_t *\fP\fImutex\fP\fB);\fP \fBint pthread_cond_timedwait(pthread_cond_t *\fP\fIcond\fP\fB, pthread_mutex_t *\fP\fImutex\fP\fB,\fP \fB const struct timespec *\fP\fIabstime\fP\fB);\fP \fBint pthread_cond_destroy(pthread_cond_t *\fP\fIcond\fP\fB);\fP .fi . . .SH DESCRIERE O condiție (prescurtare de la „variabilă de condiție”) este un mecanism de sincronizare care permite firelor de execuție să suspende execuția și să cedeze procesoarele până când este satisfăcută o anumită condiție (un predicat) privind datele partajate. Operațiile de bază ale condițiilor sunt: semnalizarea condiției (când predicatul devine adevărat) și așteptarea condiției, suspendând execuția firului până când un alt fir semnalizează condiția. .P O variabilă de condiție trebuie să fie întotdeauna asociată cu un mutex, pentru a evita condiția de „competiție pentru obținerea de date” în care un fir se pregătește să aștepte pe o variabilă de condiție și un alt fir semnalizează condiția chiar înainte ca primul fir să aștepte efectiv pe ea. .P \fBpthread_cond_init\fP inițializează variabila de condiție \fIcond\fP, utilizând atributele de condiție specificate în \fIcond_attr\fP sau atributele implicite dacă \fIcond_attr\fP este \fBNULL\fP. Implementarea „LinuxThreads” nu acceptă atribute pentru condiții, prin urmare parametrul \fIcond_attr\fP este de fapt ignorat. .P Variabilele de tip \fBpthread_cond_t\fP pot fi, de asemenea, inițializate static, utilizând constanta \fBPTHREAD_COND_INITIALIZER\fP. .P \fBpthread_cond_signal\fP repornește unul dintre firele care așteaptă variabila de condiție \fIcond\fP. În cazul în care niciun fir de execuție nu așteaptă pe \fIcond\fP, nu se întâmplă nimic. În cazul în care mai multe fire așteaptă pe \fIcond\fP, se repornește exact unul dintre ele, dar nu se specifică care. .P \fBpthread_cond_broadcast\fP repornește toate firele care așteaptă variabila de condiție \fIcond\fP. Nu se întâmplă nimic dacă niciun fir de execuție nu așteaptă pe \fIcond\fP. .P \fBpthread_cond_wait\fP deblochează atomic \fImutex\fP (conform \fBpthread_unlock_mutex\fP) și așteaptă ca variabila de condiție \fIcond\fP să fie semnalată. Execuția firului este suspendată și nu consumă timp de procesare până când variabila de condiție este semnalată. \fImutex\fP trebuie să fie blocată de firul apelant la intrarea în \fBpthread_cond_wait\fP. Înainte de a reveni la firul apelant, \fBpthread_cond_wait\fP recuperează \fImutex\fP (conform \fBpthread_lock_mutex\fP). .P Deblocarea mutex\-ului și suspendarea pe variabila de condiție se face atomic. Astfel, dacă toate firele achiziționează întotdeauna mutex\-ul înainte de a semnaliza condiția, acest lucru garantează că condiția nu poate fi semnalată (și, prin urmare, ignorată) între momentul în care un fir blochează mutex\-ul și momentul în care așteaptă pe variabila de condiție. .P \fBpthread_cond_timedwait\fP deblochează atomic \fImutex\fP și așteaptă pe \fIcond\fP, la fel ca \fBpthread_cond_wait\fP, dar limitează și durata așteptării. Dacă \fIcond\fP nu a fost semnalată în intervalul de timp specificat de \fIabstime\fP, mutex\-ul \fImutex\fP este reacceptat din nou, iar \fBpthread_cond_timedwait\fP returneazǎ eroarea \fBETIMEDOUT\fP. Parametrul \fIabstime\fP specifică un timp absolut, cu aceeași origine ca și \fBtime\fP(2) și \fBgettimeofday\fP(2): un \fIabstime\fP de 0 corespunde la 00:00:00 GMT, 1 ianuarie 1970. .P \fBpthread_cond_destroy\fP distruge o variabilă de condiție, eliberând resursele pe care le\-ar putea conține. La intrarea în \fBpthread_cond_destroy\fP nu trebuie să existe fire de execuție care să aștepte variabila de condiție. În implementarea „LinuxThreads”, nu există resurse asociate variabilelor de condiție, astfel încât \fBpthread_cond_destroy\fP nu face de fapt nimic, cu excepția verificării faptului că nu există fire de execuție în așteptare. . . .SH ANULARE \fBpthread_cond_wait\fP și \fBpthread_cond_timedwait\fP sunt puncte de anulare. Dacă un fir este anulat în timp ce este suspendat într\-una din aceste funcții, firul își reia imediat execuția, apoi blochează din nou argumentul \fImutex\fP la \fBpthread_cond_wait\fP și \fBpthread_cond_timedwait\fP și, în final, execută anularea. În consecință, gestionarii de curățare sunt asigurați că \fImutex\fP este blocat atunci când sunt apelați. . . .SH "SIGURANȚA SEMNALELOR ASINCRONE" Funcțiile de condiție nu sunt sigure pentru semnale asincrone și nu ar trebui să fie apelate de la un gestionar de semnal. În special, apelarea \fBpthread_cond_signal\fP sau \fBpthread_cond_broadcast\fP de la un gestionar de semnal poate bloca firul apelant. . . .SH "VALOAREA RETURNATĂ" Toate funcțiile de variabilă de condiție returnează 0 în caz de succes și un cod de eroare diferit de zero în caz de eroare. . . .SH ERORI\-IEȘIRE \fBpthread_cond_init\fP, \fBpthread_cond_signal\fP, \fBpthread_cond_broadcast\fP și \fBpthread_cond_wait\fP nu returnează niciodată un cod de eroare. .P Funcția \fBpthread_cond_timedwait\fP returnează următoarele coduri de eroare în caz de eroare: .RS .TP \fBETIMEDOUT\fP Variabila de condiție nu a fost semnalată până la expirarea timpului de așteptare specificat de \fIabstime\fP. .TP \fBEINTR\fP \fBpthread_cond_timedwait\fP a fost întrerupt de un semnal. .RE .P Funcția \fBpthread_cond_destroy\fP returnează următorul cod de eroare în caz de eroare: .RS .TP \fBEBUSY\fP Unele fire sunt în prezent în așteptare pe \fIcond\fP. .RE . . .SH "CONSULTAȚI ȘI" \fBpthread_condattr_init\fP(3), \fBpthread_mutex_lock\fP(3), \fBpthread_mutex_unlock\fP(3), \fBgettimeofday\fP(2), \fBnanosleep\fP(2). . . .SH EXEMPLU Se consideră două variabile partajate \fIx\fP și \fIy\fP, protejate de mutex\-ul \fImut\fP, și o variabilă de condiție \fIcond\fP care trebuie semnalată ori de câte ori \fIx\fP devine mai mare decât \fIy\fP. .P .RS .nf .sp \fBint x,y; pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER; pthread_cond_t cond = PTHREAD_COND_INITIALIZER;\fP .RE .fi .P Așteptarea până când \fIx\fP este mai mare decât \fIy\fP se efectuează după cum urmează: .P .RS .nf .sp \fBpthread_mutex_lock(&mut); while (x <= y) { pthread_cond_wait(&cond, &mut); } /* operează asupra lui x și y */ pthread_mutex_unlock(&mut);\fP .RE .fi .P Modificările lui \fIx\fP și \fIy\fP care pot face ca \fIx\fP să devină mai mare decât \fIy\fP trebuie să semnalizeze condiția, dacă este necesar: .P .RS .nf .sp \fBpthread_mutex_lock(&mut); /* modificarea lui x și y */ if (x > y) pthread_cond_broadcast(&cond); pthread_mutex_unlock(&mut);\fP .RE .fi .P Dacă se poate dovedi că cel mult un singur fir în așteptare trebuie să fie trezit (de exemplu, dacă există doar două fire care comunică prin \fIx\fP și \fIy\fP), \fBpthread_cond_signal\fP poate fi utilizat ca o alternativă puțin mai eficientă la \fBpthread_cond_broadcast\fP. În caz de îndoială, utilizați \fBpthread_cond_broadcast\fP. .P Pentru a aștepta ca \fIx\fP să devină mai mare decât \fIy\fP cu un timp de așteptare de 5 secunde, faceți: .P .RS .nf .sp \fBstruct 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 { /* operează asupra lui x și y */ } pthread_mutex_unlock(&mut);\fP .RE .fi .PP .SH TRADUCERE Traducerea în limba română a acestui manual a fost făcută de Remus-Gabriel Chelu . .PP Această traducere este documentație gratuită; citiți .UR https://www.gnu.org/licenses/gpl-3.0.html Licența publică generală GNU Versiunea 3 .UE sau o versiune ulterioară cu privire la condiții privind drepturile de autor. NU se asumă NICIO RESPONSABILITATE. .PP Dacă găsiți erori în traducerea acestui manual, vă rugăm să trimiteți un e-mail la .MT translation-team-ro@lists.sourceforge.net .ME .