.\" -*- coding: UTF-8 -*- .\"******************************************************************* .\" .\" This file was generated with po4a. Translate the source file. .\" .\"******************************************************************* .TH PTHREAD_SPECIFIC 3 LinuxThreads .SH NUME pthread_key_create, pthread_key_delete, pthread_setspecific, pthread_getspecific \- gestionarea datelor specifice firului de execuție .SH REZUMAT \fB#include \fP \fBint pthread_key_create(pthread_key_t *\fP\fIkey\fP\fB, void (*\fP\fIdestr_function\fP\fB) (void *));\fP \fBint pthread_key_delete(pthread_key_t \fP\fIkey\fP\fB);\fP \fBint pthread_setspecific(pthread_key_t \fP\fIkey\fP\fB, const void *\fP\fIpointer\fP\fB);\fP \fBvoid * pthread_getspecific(pthread_key_t \fP\fIkey\fP\fB);\fP .SH DESCRIERE Programele au adesea nevoie de variabile globale sau statice care au valori diferite în diferite fire de execuție. Deoarece firele de execuție împart un singur spațiu de memorie, acest lucru nu poate fi realizat cu variabile obișnuite. Datele specifice firelor de execuție reprezintă răspunsul POSIX la această necesitate. Fiecare fir de execuție are un bloc de memorie privat, zona de date specifică firului de execuție sau, pe scurt, zona TSD. Această zonă este indexată cu ajutorul cheilor TSD. Zona TSD asociază valori de tip \fBvoid *\fP cheilor TSD. Cheile TSD sunt comune tuturor firelor, dar valoarea asociată unei anumite chei TSD poate fi diferită în fiecare fir. Pentru a fi mai concreți, zonele TSD pot fi considerate ca fiind matrice de indicatori \fBvoid *\fP, cheile TSD ca indici întregi în aceste matrice, iar valoarea unei chei TSD ca valoare a elementului de matrice corespunzător în firul de apelare. Atunci când este creat un fir, zona TSD a acestuia asociază inițial \fBNULL\fP cu toate cheile. \fBpthread_key_create\fP alocă o nouă cheie TSD. Cheia este stocată în locația indicată de \fIkey\fP. Există o limită de \fBPTHREAD_KEYS_MAX\fP pentru numărul de chei alocate la un moment dat. Valoarea asociată inițial cheii returnate este \fBNULL\fP în toate firele de execuție în curs. Argumentul \fIdestr_function\fP, dacă nu este \fBNULL\fP, specifică o funcție de distrugere asociată cu cheia. Atunci când un fir de execuție se termină prin \fBpthread_exit\fP sau prin anulare, \fIdestr_function\fP este apelată cu argumentele valorii asociate cheii în acel fir de execuție. \fIdestr_function\fP nu este apelată dacă valoarea respectivă este \fBNULL\fP. Ordinea în care sunt apelate funcțiile de distrugere în momentul terminării firului nu este specificată. Înainte de apelarea funcției de distrugere, valoarea \fBNULL\fP este asociată cu cheia în firul curent. Cu toate acestea, o funcție de distrugere ar putea reasocia valorile non\-\fBNULL\fP la această cheie sau la o altă cheie. Pentru a rezolva această problemă, dacă, după ce toți destructorii au fost apelați pentru toate valorile non\-\fBNULL\fP, mai există încă valori non\-\fBNULL\fP cu destructori asociați, procesul se repetă. Implementarea „LinuxThreads” oprește procesul după \fBPTHREAD_DESTRUCTOR_ITERATIONS\fP iterații, chiar dacă mai rămân câteva valori non\-\fBNULL\fP cu descriptori asociați. Alte implementări pot efectua bucle la nesfârșit. \fBpthread_key_delete\fP anulează alocarea unei chei TSD. Nu verifică dacă există valori non\-\fBNULL\fP asociate cu cheia respectivă în firele de execuție în curs de execuție și nici nu apelează funcția de distrugere asociată cu cheia. \fBpthread_setspecific\fP modifică valoarea asociată cu \fIkey\fP în firul de apelare, stocând în schimb \fIpointer\fP\-ul dat. \fBpthread_getspecific\fP returnează valoarea asociată în prezent cu \fIkey\fP în firul de apelare. .SH "VALOAREA RETURNATĂ" \fBpthread_key_create\fP, \fBpthread_key_delete\fP și \fBpthread_setspecific\fP returnează 0 în caz de succes și un cod de eroare diferit de zero în caz de eșec. În caz de succes, \fBpthread_key_create\fP stochează cheia nou alocată în locația indicată de argumentul său \fIkey\fP. \fBpthread_getspecific\fP returnează valoarea asociată cu \fIkey\fP în caz de succes, și \fBNULL\fP în caz de eroare. .SH ERORI\-IEȘIRE În caz de eroare, \fBpthread_key_create\fP returnează următorul cod de eroare: .RS .TP \fBEAGAIN\fP Cheile \fBPTHREAD_KEYS_MAX\fP sunt deja alocate .RE În caz de eroare, \fBpthread_key_delete\fP și \fBpthread_setspecific\fP returnează următorul cod de eroare: .RS .TP \fBEINVAL\fP \fIkey\fP nu este o cheie TSD validă, alocată .RE \fBpthread_getspecific\fP returnează \fBNULL\fP dacă \fIkey\fP nu este o cheie TSD validă, alocată. .SH AUTOR Xavier Leroy .SH "CONSULTAȚI ȘI" pthread_create(3), pthread_exit(3), pthread_testcancel(3). .SH EXEMPLU Următorul fragment de cod alocă o matrice de 100 de caractere specifică firului de execuție, cu recuperare automată la ieșirea din fir: .RS .nf .sp \fB/* Cheia pentru memoria tampon specifică firului */ static pthread_key_t buffer_key;\fP \fB/* Inițializarea o singură dată a cheii */ static pthread_once_t buffer_key_once = PTHREAD_ONCE_INIT;\fP \fB/* Alocarea memoriei tampon specifice firului */ void buffer_alloc(void) { pthread_once(&buffer_key_once, buffer_key_alloc); pthread_setspecific(buffer_key, malloc(100)); }\fP \fB/* Returnează memoria tampon specifică firului */ char * get_buffer(void) { return (char *) pthread_getspecific(buffer_key); }\fP \fB/* Alocarea cheii */ static void buffer_key_alloc() { pthread_key_create(&buffer_key, buffer_destroy); }\fP \fB/* Eliberează memoria tampon specifică firului */ static void buffer_destroy(void * buf) { free(buf); }\fP .LP .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 .