.\" -*- coding: UTF-8 -*- '\" t .\" Copyright (c) 2008 Linux Foundation, written by Michael Kerrisk .\" .\" .\" SPDX-License-Identifier: Linux-man-pages-copyleft .\" .\"******************************************************************* .\" .\" This file was generated with po4a. Translate the source file. .\" .\"******************************************************************* .TH pthread_cancel 3 "5 noiembrie 2024" "Pagini de manual de Linux 6.12" .SH NUME pthread_cancel \- trimite o cerere de anulare către un fir .SH BIBLIOTECA Biblioteca de fire de execuție POSIX (\fIlibpthread\fP, \fI\-lpthread\fP) .SH SINOPSIS .nf \fB#include \fP .P \fBint pthread_cancel(pthread_t \fP\fIthread\fP\fB);\fP .fi .SH DESCRIERE Funcția \fBpthread_cancel\fP() trimite o cerere de anulare către firul \fIthread\fP. Dacă și când reacționează firul țintă la cererea de anulare depinde de două atribute care se află sub controlul firului respectiv: capacitatea sa de anulare \fIstate\fP și \fItype\fP. .P Starea de anulare a unui fir, determinată de \fBpthread_setcancelstate\fP(3), poate fi \fIenabled\fP (implicit pentru firele noi) sau \fIdisabled\fP. Dacă un fir are anularea dezactivată, atunci o cerere de anulare rămâne în așteptare până când firul activează anularea. Dacă un fir a activat anularea, atunci tipul său de anulare determină momentul în care are loc anularea. .P Tipul de anulare a unui fir, determinat de \fBpthread_setcanceltype\fP(3), poate fi fie \fIasincron\fP, fie \fIdeferred\fP (implicit pentru firele noi). Anulabilitatea asincronă înseamnă că firul poate fi anulat în orice moment (de obicei imediat, dar sistemul nu garantează acest lucru). Capacitatea de anulare amânată înseamnă că anularea va fi amânată până când firul va apela o funcție care este un \fIpunct de anulare\fP. O listă de funcții care sunt sau pot fi puncte de anulare este furnizată în \fBpthreads\fP(7). .P Atunci când se dă curs unei cereri de anulare, pentru \fIthread\fP au loc următoarele etape (în această ordine): .IP (1) 5 Gestionarii de curățare a anulării sunt scoși (în ordinea inversă a ordinii în care au fost introduși) și apelați; (a se vedea \fBpthread_cleanup_push\fP(3).) .IP (2) Destructorii de date specifici firelor sunt apelați, într\-o ordine nespecificată; (a se vedea \fBpthread_key_create\fP(3).) .IP (3) Firul este terminat; (a se vedea \fBpthread_exit\fP(3)). .P Etapele de mai sus au loc în mod asincron în ceea ce privește apelul \fBpthread_cancel\fP(); starea de retur a apelului \fBpthread_cancel\fP() informează doar apelantul dacă cererea de anulare a fost pusă în coadă cu succes. .P După terminarea unui fir de execuție anulat, o asociere cu acel fir de execuție folosind \fBpthread_join\fP(3) obține \fBPTHREAD_CANCELED\fP ca stare de ieșire a firului de execuție; (unirea cu un fir este singura modalitate de a ști că anularea s\-a încheiat). .SH "VALOAREA RETURNATĂ" În caz de succes, \fBpthread_cancel\fP() returnează 0; în caz de eroare, returnează un număr de eroare diferit de zero. .SH ERORI\-IEȘIRE .TP \fBESRCH\fP Nu a putut fi găsit niciun fir de execuție cu identificatorul \fIthread\fP. .SH ATRIBUTE Pentru o explicație a termenilor folosiți în această secțiune, a se vedea \fBattributes\fP(7). .TS allbox; lbx lb lb l l l. Interfață Atribut Valoare T{ .na .nh \fBpthread_cancel\fP() T} Siguranța firelor MT\-Safe .TE .SH VERSIUNI În Linux, anularea este implementată utilizând semnale. În cadrul implementării threading NPTL, primul semnal în timp real (adică semnalul 32) este utilizat în acest scop. În LinuxThreads, se utilizează al doilea semnal în timp real, dacă sunt disponibile semnale în timp real, altfel se utilizează \fBSIGUSR2\fP. .SH STANDARDE POSIX.1\-2008. .SH ISTORIC glibc 2.0 POSIX.1\-2001. .SH EXEMPLE Programul de mai jos creează un fir și apoi îl anulează. Firul principal se unește cu firul anulat pentru a verifica dacă starea sa de ieșire a fost \fBPTHREAD_CANCELED\fP. Următoarea sesiune shell arată ce se întâmplă atunci când rulăm programul: .P .in +4n .EX $ ./a.out thread_func(): pornit; anulare dezactivată main(): se trimite cererea de anulare thread_func(): privind activarea anulării main(): firul a fost anulat .EE .in .SS "Sursa programului" .\" SRC BEGIN (pthread_cancel.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 void * thread_func(void *ignored_argument) { int s; \& /* Dezactivează anularea pentru o perioadă, astfel încât să nu reacționăm imediat la o cerere de anulare. */ \& s = pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL); if (s != 0) handle_error_en(s, "pthread_setcancelstate"); \& printf("%s(): pornit; anulare dezactivată\[rs]n", __func__); sleep(5); printf("%s(): privind activarea anulării\[rs]n", __func__); \& s = pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); if (s != 0) handle_error_en(s, "pthread_setcancelstate"); \& /* sleep() este un punct de anulare. */ \& sleep(1000); /* Ar trebui să se anuleze în timp ce dormim */ \& /* N\-ar trebui să ajungă niciodată aici. */ \& printf("%s(): nu este anulat!\[rs]n", __func__); return NULL; } \& int main(void) { pthread_t thr; void *res; int s; \& /* Începe un fir și apoi îi trimite o cerere de anulare. */ \& s = pthread_create(&thr, NULL, &thread_func, NULL); if (s != 0) handle_error_en(s, "pthread_create"); \& sleep(2); /* Dă firului o șansă de a începe */ \& printf("%s(): se trimite cererea de anulare\[rs]n", __func__); s = pthread_cancel(thr); if (s != 0) handle_error_en(s, "pthread_cancel"); \& /* Se alătură firului pentru a vedea care a fost starea sa de ieșire. */ \& s = pthread_join(thr, &res); if (s != 0) handle_error_en(s, "pthread_join"); \& if (res == PTHREAD_CANCELED) printf("%s(): firul a fost anulat\[rs]n", __func__); else printf("%s(): firul nu a fost anulat (nu ar trebui să se întâmple!)\[rs]n", __func__); exit(EXIT_SUCCESS); } .EE .\" SRC END .SH "CONSULTAȚI ȘI" .ad l .nh \fBpthread_cleanup_push\fP(3), \fBpthread_create\fP(3), \fBpthread_exit\fP(3), \fBpthread_join\fP(3), \fBpthread_key_create\fP(3), \fBpthread_setcancelstate\fP(3), \fBpthread_setcanceltype\fP(3), \fBpthread_testcancel\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 .