.\" -*- coding: UTF-8 -*- .\" Copyright (c) 2017, Yubin Ruan .\" and Copyright (c) 2017, Michael Kerrisk .\" .\" SPDX-License-Identifier: Linux-man-pages-copyleft .\" .\"******************************************************************* .\" .\" This file was generated with po4a. Translate the source file. .\" .\"******************************************************************* .TH pthread_mutexattr_setrobust 3 "23 iulie 2024" "Pagini de manual de Linux 6.12" .SH NUME pthread_mutexattr_getrobust, pthread_mutexattr_setrobust \- obține și definește atributul de robustețe al unui obiect cu atribute mutex .SH BIBLIOTECA Biblioteca de fire de execuție POSIX (\fIlibpthread\fP, \fI\-lpthread\fP) .SH SINOPSIS .nf \fB#include \fP .P \fBint pthread_mutexattr_getrobust(const pthread_mutexattr_t *\fP\fIattr\fP\fB,\fP \fB int *\fP\fIrobustness\fP\fB);\fP \fBint pthread_mutexattr_setrobust(pthread_mutexattr_t *\fP\fIattr\fP\fB,\fP \fB int \fP\fIrobustness\fP\fB);\fP .fi .P .RS -4 Cerințe pentru macrocomenzi de testare a caracteristicilor pentru glibc (consultați \fBfeature_test_macros\fP(7)): .RE .P \fBpthread_mutexattr_getrobust\fP(), \fBpthread_mutexattr_setrobust\fP(): .nf .\" FIXME . .\" But see https://sourceware.org/bugzilla/show_bug.cgi?id=22125 _POSIX_C_SOURCE >= 200809L .fi .SH DESCRIERE Funcția \fBpthread_mutexattr_getrobust\fP() plasează în \fI*robustness\fP valoarea atributului de robustețe al obiectului de atribute mutex la care se referă \fIattr\fP. Funcția \fBpthread_mutexattr_setrobust\fP() stabilește valoarea atributului robustețe al obiectului atribute mutex la care face referire \fIattr\fP la valoarea specificată în \fI*robustness\fP. .P Atributul „robustness” specifică comportamentul mutex\-ului atunci când firul proprietar moare fără să deblocheze mutex\-ul. Următoarele valori sunt valabile pentru \fIrobustness\fP: .TP \fBPTHREAD_MUTEX_STALLED\fP Aceasta este valoarea implicită pentru un obiect cu atribute mutex. Dacă un mutex este inițializat cu atributul \fBPTHREAD_MUTEX_STALLED\fP și proprietarul său moare fără să\-l deblocheze, mutex\-ul rămâne blocat ulterior și orice încercare viitoare de a apela \fBpthread_mutex_lock\fP(3) pe mutex se va bloca pe termen nelimitat. .TP \fBPTHREAD_MUTEX_ROBUST\fP Dacă un mutex este inițializat cu atributul \fBPTHREAD_MUTEX_ROBUST\fP și proprietarul său moare fără a\-l debloca, orice încercare viitoare de a apela \fBpthread_mutex_lock\fP(3) pe acest mutex va reuși și va returna \fBEOWNERDEAD\fP pentru a indica faptul că proprietarul inițial nu mai există și că mutex\-ul este într\-o stare inconsistentă. De obicei, după ce \fBEOWNERDEAD\fP este returnat, următorul proprietar ar trebui să apeleze \fBpthread_mutex_consistent\fP(3) pe mutex\-ul achiziționat pentru a\-l face din nou consistent înainte de a\-l utiliza în continuare. .IP Dacă următorul proprietar deblochează mutex\-ul folosind \fBpthread_mutex_unlock\fP(3) înainte de a\-l face consistent, mutex\-ul va fi permanent inutilizabil și orice încercare ulterioară de a\-l bloca folosind \fBpthread_mutex_lock\fP(3) va eșua cu eroarea \fBENOTRECOVERABLE\fP. Singura operație permisă pe un astfel de mutex este \fBpthread_mutex_destroy\fP(3). .IP Dacă următorul proprietar încetează activitatea înainte de a apela \fBpthread_mutex_consistent\fP(3), operațiile ulterioare \fBpthread_mutex_lock\fP(3) asupra acestui mutex vor returna în continuare \fBEOWNERDEAD\fP. .P Rețineți că argumentul \fIattr\fP din \fBpthread_mutexattr_getrobust\fP() și \fBpthread_mutexattr_setrobust\fP() trebuie să se refere la un obiect de atribute mutex care a fost inițializat de \fBpthread_mutexattr_init\fP(3), în caz contrar comportamentul este indefinit. .SH "VALOAREA RETURNATĂ" În caz de succes, aceste funcții returnează 0. În caz de eroare, acestea returnează un număr pozitiv de eroare. .P În implementarea glibc, \fBpthread_mutexattr_getrobust\fP() returnează întotdeauna zero. .SH ERORI\-IEȘIRE .TP \fBEINVAL\fP O altă valoare decât \fBPTHREAD_MUTEX_STALLED\fP sau \fBPTHREAD_MUTEX_ROBUST\fP a fost trecută la \fBpthread_mutexattr_setrobust\fP(). .SH VERSIUNI .\" E.g., Solaris, according to its manual page În implementarea Linux, atunci când se utilizează mutex\-uri robuste partajate de proces, un fir în așteptare primește și notificarea \fBEOWNERDEAD\fP dacă proprietarul unui mutex robust efectuează un \fBexecve\fP(2) fără a debloca mai întâi mutex\-ul. POSIX.1 nu specifică acest detaliu, dar același comportament apare și în cel puțin alte implementări. .SH STANDARDE POSIX.1\-2008. .SH ISTORIC glibc 2.12. POSIX.1\-2008. .P Înainte de adăugarea la POSIX a funcțiilor \fBpthread_mutexattr_getrobust\fP() și \fBpthread_mutexattr_setrobust\fP(), glibc a definit următoarele funcții non\-standard echivalente dacă \fB_GNU_SOURCE\fP era definită: .P .nf \fB[[depreciat]\fP \fBint pthread_mutexattr_getrobust_np(const pthread_mutexattr_t *\fP\fIattr\fP\fB,\fP \fB int *\fP\fIrobustness\fP\fB);\fP \fB[[depreciat]\fP \fBint pthread_mutexattr_setrobust_np(const pthread_mutexattr_t *\fP\fIattr\fP\fB,\fP \fB int \fP\fIrobustness\fP\fB);\fP .fi .P În consecință, au fost definite și constantele \fBPTHREAD_MUTEX_STALLED_NP\fP și \fBPTHREAD_MUTEX_ROBUST_NP\fP. .P Aceste API\-uri specifice GNU, care au apărut pentru prima dată în glibc 2.4, sunt în prezent învechite și nu ar trebui utilizate în programe noi; începând cu glibc 2.34 aceste API\-uri sunt marcate ca fiind depreciate. .SH EXEMPLE Programul de mai jos demonstrează utilizarea atributului „robustness” al unui obiect cu atribute mutex. În acest program, un fir care deține mutex\-ul moare prematur fără să deblocheze mutex\-ul. Firul principal dobândește ulterior mutex\-ul cu succes și primește eroarea \fBEOWNERDEAD\fP, după care face mutex\-ul consistent. .P Următoarea sesiune shell arată ce vedem la rularea acestui program: .P .in +4n .EX $ \fB./a.out\fP [proprietarul original ] Amplasarea blocării... [proprietarul original] Blocat. Acum ies fără să deblochez. [main] Se încearcă blocarea mutex\-ului robust. [main] pthread_mutex_lock() a returnat EOWNERDEAD [main] Acum se face mutex\-ul consistent [main] Mutex\-ul este acum consistent; se deblochează .EE .in .SS "Sursa programului" .\" SRC BEGIN (pthread_mutexattr_setrobust.c) .EX #include #include #include #include #include \& #define handle_error_en(en, msg) \[rs] do { errno = en; perror(msg); exit(EXIT_FAILURE); } while (0) \& static pthread_mutex_t mtx; \& static void * original_owner_thread(void *ptr) { printf("[proprietarul original ] Amplasarea blocării...\[rs]n"); pthread_mutex_lock(&mtx); printf("[proprietarul original] Blocat. Acum ies fără să deblochez.\[rs]n"); pthread_exit(NULL); } \& int main(void) { pthread_t thr; pthread_mutexattr_t attr; int s; \& pthread_mutexattr_init(&attr); \& pthread_mutexattr_setrobust(&attr, PTHREAD_MUTEX_ROBUST); \& pthread_mutex_init(&mtx, &attr); \& pthread_create(&thr, NULL, original_owner_thread, NULL); \& sleep(2); \& /* „original_owner_thread” ar trebui să fi ieșit până acum. */ \& printf("[main] Se încearcă blocarea mutex\-ului robust.\[rs]n"); s = pthread_mutex_lock(&mtx); if (s == EOWNERDEAD) { printf("[main] pthread_mutex_lock() a returnat EOWNERDEAD\[rs]n"); printf("[main] Acum se face mutex\-ul consistent\[rs]n"); s = pthread_mutex_consistent(&mtx); if (s != 0) handle_error_en(s, "pthread_mutex_consistent"); printf("[main] Mutex\-ul este acum consistent; se deblochează\[rs]n"); s = pthread_mutex_unlock(&mtx); if (s != 0) handle_error_en(s, "pthread_mutex_unlock"); \& exit(EXIT_SUCCESS); } else if (s == 0) { printf("[main] pthread_mutex_lock() a reușit în mod neașteptat\[rs]n"); exit(EXIT_FAILURE); } else { printf("[main] pthread_mutex_lock() a eșuat în mod neașteptat[main]\[rs]n"); handle_error_en(s, "pthread_mutex_lock"); } } .EE .\" SRC END .SH "CONSULTAȚI ȘI" .ad l .nh \fBget_robust_list\fP(2), \fBset_robust_list\fP(2), \fBpthread_mutex_consistent\fP(3), \fBpthread_mutex_init\fP(3), \fBpthread_mutex_lock\fP(3), \fBpthreads\fP(7) .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 .