.\" -*- 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_mutex_init 3 "19 mai 2024" "Pagini de manual de Linux 6.8" . . .SH NUME pthread_mutex_init, pthread_mutex_lock, pthread_mutex_trylock, pthread_mutex_unlock, pthread_mutex_destroy \- operații asupra mutex\-urilor . . .SH SINOPSIS .nf \fB#include \fP .P \fBpthread_mutex_t \fP\fIfastmutex\fP\fB = PTHREAD_MUTEX_INITIALIZER;\fP \fBpthread_mutex_t \fP\fIrecmutex\fP\fB = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;\fP \fBpthread_mutex_t \fP\fIerrchkmutex\fP\fB = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;\fP .P \fBint pthread_mutex_init(pthread_mutex_t *\fP\fImutex\fP\fB,\fP \fB const pthread_mutexattr_t *\fP\fImutexattr\fP\fB);\fP \fBint pthread_mutex_lock(pthread_mutex_t *\fP\fImutex\fP\fB);\fP \fBint pthread_mutex_trylock(pthread_mutex_t *\fP\fImutex\fP\fB);\fP \fBint pthread_mutex_unlock(pthread_mutex_t *\fP\fImutex\fP\fB);\fP \fBint pthread_mutex_destroy(pthread_mutex_t *\fP\fImutex\fP\fB);\fP .fi . . .SH DESCRIERE Un mutex este un dispozitiv de EXCLUDERE MUTUALĂ „MUTual EXclusion” și este util pentru protejarea structurilor de date partajate împotriva modificărilor simultane și pentru implementarea secțiunilor critice și a monitorizărilor. .P Un mutex are două stări posibile: deblocat (nu este deținut de niciun fir) și blocat (este deținut de un singur fir). Un mutex nu poate fi niciodată deținut simultan de două fire diferite. Un fir care încearcă să blocheze un mutex care este deja blocat de un alt fir este suspendat până când firul proprietar deblochează primul mutex. .P \fBpthread_mutex_init\fP inițializează obiectul mutex indicat de \fImutex\fP în conformitate cu atributele mutex specificate în \fImutexattr\fP. În cazul în care \fImutexattr\fP este \fBNULL\fP, se utilizează în schimb atributele implicite. .P Implementarea LinuxThreads acceptă doar un singur atribut mutex, \fImutex kind\fP, care este fie „fast”, „recursive”, fie „error checking”. Tipul unui mutex determină dacă acesta poate fi blocat din nou de un fir care îl deține deja. Tipul implicit este „fast”. A se vedea \fBpthread_mutexattr_init\fP(3) pentru mai multe informații despre atributele mutex\-urilor. .P Variabilele de tip \fBpthread_mutex_t\fP pot fi, de asemenea, inițializate static, utilizând constantele \fBPTHREAD_MUTEX_INITIALIZER\fP (pentru mutex\-uri rapide), \fBPTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP\fP (pentru mutex\-uri recursive) și \fBPTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP\fP (pentru mutex\-uri de verificare a erorilor). .P \fBpthread_mutex_lock\fP blochează mutex\-ul dat. Dacă mutex\-ul este în prezent deblocat, acesta devine blocat și este deținut de firul apelant, iar \fBpthread_mutex_lock\fP returnează imediat. Dacă mutex\-ul este deja blocat de un alt fir de execuție, \fBpthread_mutex_lock\fP suspendă firul apelant până când mutex\-ul este deblocat. .P În cazul în care mutex\-ul este deja blocat de firul apelant, comportamentul lui \fBpthread_mutex_lock\fP depinde de tipul mutex\-ului. În cazul în care mutex\-ul este de tipul „fast”, firul apelant este suspendat până când mutex\-ul este deblocat, ceea ce duce efectiv la blocarea firului apelant. În cazul în care mutex\-ul este de tipul „error checking”, \fBpthread_mutex_lock\fP returnează imediat cu codul de eroare \fBEDEADLK\fP. În cazul în care mutex\-ul este de tip „recursive”, \fBpthread_mutex_lock\fP reușește și returnează imediat, înregistrând numărul de blocări ale mutex\-ului de către firul apelant. Un număr egal de operații \fBpthread_mutex_unlock\fP trebuie efectuate înainte ca mutex\-ul să revină la starea deblocată. .P \fBpthread_mutex_trylock\fP se comportă în mod identic cu \fBpthread_mutex_lock\fP, cu excepția faptului că nu blochează firul apelant dacă mutex\-ul este deja blocat de un alt fir (sau de firul apelant în cazul unui mutex „fast”). În schimb, \fBpthread_mutex_trylock\fP returnează imediat cu codul de eroare \fBEBUSY\fP. .P \fBpthread_mutex_unlock\fP deblochează mutex\-ul dat. Se presupune că mutex\-ul este blocat și deținut de firul apelant la intrarea în \fBpthread_mutex_unlock\fP. În cazul în care mutex\-ul este de tip „fast”, \fBpthread_mutex_unlock\fP îl readuce întotdeauna în starea deblocată. În cazul în care este de tip „recursive”, B descrește numărul de blocaje ale mutex\-ului (numărul de operații \fBpthread_mutex_lock\fP efectuate asupra acestuia de către firul apelant) și numai atunci când acest număr ajunge la zero, mutex\-ul este efectiv deblocat. .P În cazul mutex\-urilor „error checking” și „recursive”, \fBpthread_mutex_unlock\fP verifică de fapt în timpul execuției dacă mutex\-ul este blocat la intrare și dacă a fost blocat de același fir care apelează acum \fBpthread_mutex_unlock\fP. În cazul în care aceste condiții nu sunt îndeplinite, se returnează un cod de eroare, iar mutex\-ul rămâne neschimbat. Mutex\-urile „fast” nu efectuează astfel de verificări, permițând astfel ca un mutex blocat să fie deblocat de către un alt fir de execuție decât proprietarul său. Acesta este un comportament neportabil și nu trebuie să se bazeze pe el. .P \fBpthread_mutex_destroy\fP distruge un obiect mutex, eliberând resursele pe care le\-ar putea deține. Mutex\-ul trebuie să fie deblocat la intrare. În implementarea LinuxThreads, nicio resursă nu este asociată cu obiectele mutex, astfel încât \fBpthread_mutex_destroy\fP nu face de fapt nimic, cu excepția verificării faptului că mutex\-ul este deblocat. . . .SH ANULARE Niciuna dintre funcțiile mutex nu este un punct de anulare, nici măcar \fBpthread_mutex_lock\fP, în ciuda faptului că poate suspenda un fir de execuție pentru durate arbitrare. În acest fel, starea mutex\-urilor la punctele de anulare este previzibilă, permițând operatorilor de anulare să deblocheze exact acele mutex\-uri care trebuie deblocate înainte ca firul să se oprească din execuție. În consecință, firele care utilizează anularea amânată nu ar trebui să dețină niciodată un mutex pentru perioade lungi de timp. . . .SH "SIGURANȚA SEMNALELOR ASINCRONE" Funcțiile mutex nu sunt sigure pentru semnalul asincron. Acest lucru înseamnă că nu trebuie apelate de la un gestionar de semnal. În special, apelarea funcțiilor \fBpthread_mutex_lock\fP sau \fBpthread_mutex_unlock\fP de la un gestionar de semnal poate bloca firul apelant. . . .SH "VALOAREA RETURNATĂ" \fBpthread_mutex_init\fP returnează întotdeauna 0. Celelalte funcții mutex returnează 0 în caz de succes și un cod de eroare diferit de zero în caz de eroare. . . .SH ERORI\-IEȘIRE Funcția \fBpthread_mutex_lock\fP returnează următorul cod de eroare în caz de eroare: .RS .TP \fBEINVAL\fP Mutex\-ul nu a fost inițializat corespunzător. .TP \fBEDEADLK\fP Mutex\-ul este deja blocat de firul apelant (numai mutex\-urile „error checking”). .RE .P Funcția \fBpthread_mutex_trylock\fP returnează următoarele coduri de eroare în caz de eroare: .RS .TP \fBEBUSY\fP Mutex\-ul nu a putut fi achiziționat deoarece era blocat în prezent. .TP \fBEINVAL\fP Mutex\-ul nu a fost inițializat corespunzător. .RE .P Funcția \fBpthread_mutex_unlock\fP returnează următorul cod de eroare în caz de eroare: .RS .TP \fBEINVAL\fP Mutex\-ul nu a fost inițializat corespunzător. .TP \fBEPERM\fP Firul apelant nu deține mutex\-ul (numai mutex\-urile „error checking”). .RE .P Funcția \fBpthread_mutex_destroy\fP returnează următorul cod de eroare în caz de eroare: .RS .TP \fBEBUSY\fP Mutex\-ul este blocat în prezent. .RE . . .SH "CONSULTAȚI ȘI" \fBpthread_mutexattr_init\fP(3), \fBpthread_mutexattr_setkind_np\fP(3), \fBpthread_cancel\fP(3). . . .SH EXEMPLU O variabilă globală partajată \fIx\fP poate fi protejată de un mutex după cum urmează: .P .RS .nf .sp \fBint x; pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;\fP .P .RE .fi .P Toate accesările și modificările la \fIx\fP trebuie să fie între paranteze prin apeluri la \fBpthread_mutex_lock\fP și \fBpthread_mutex_unlock\fP după cum urmează: .P .RS .nf .sp \fBpthread_mutex_lock(&mut); /* operează pe x */ pthread_mutex_unlock(&mut);\fP .P .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 .