pthread_cancel(3)          Library Functions Manual          pthread_cancel(3)

NUME
       pthread_cancel - trimite o cerere de anulare catre un fir

BIBLIOTECA
       Biblioteca de fire de execu<?>ie POSIX (libpthread, -lpthread)

SINOPSIS
       #include <pthread.h>

       int pthread_cancel(pthread_t thread);

DESCRIERE
       Func<?>ia pthread_cancel() trimite o cerere de anulare catre firul
       thread. Daca <?>i cand reac<?>ioneaza firul <?>inta la cererea de
       anulare depinde de doua atribute care se afla sub controlul firului
       respectiv: capacitatea sa de anulare state <?>i type.

       Starea de anulare a unui fir, determinata de pthread_setcancelstate(3),
       poate fi enabled (implicit pentru firele noi) sau disabled.  Daca un
       fir are anularea dezactivata, atunci o cerere de anulare ramane in
       a<?>teptare pana cand firul activeaza anularea. Daca un fir a activat
       anularea, atunci tipul sau de anulare determina momentul in care are
       loc anularea.

       Tipul de anulare a unui fir, determinat de pthread_setcanceltype(3),
       poate fi fie asincron, fie deferred (implicit pentru firele noi).
       Anulabilitatea asincrona inseamna ca firul poate fi anulat in orice
       moment (de obicei imediat, dar sistemul nu garanteaza acest lucru).
       Capacitatea de anulare amanata inseamna ca anularea va fi amanata pana
       cand firul va apela o func<?>ie care este un punct de anulare. O lista
       de func<?>ii care sunt sau pot fi puncte de anulare este furnizata in
       pthreads(7).

       Atunci cand se da curs unei cereri de anulare, pentru thread au loc
       urmatoarele etape (in aceasta ordine):

       (1)  Gestionarii de cura<?>are a anularii sunt sco<?>i (in ordinea
            inversa a ordinii in care au fost introdu<?>i) <?>i apela<?>i; (a
            se vedea pthread_cleanup_push(3).)

       (2)  Destructorii de date specifici firelor sunt apela<?>i, intr-o
            ordine nespecificata; (a se vedea pthread_key_create(3).)

       (3)  Firul este terminat; (a se vedea pthread_exit(3)).

       Etapele de mai sus au loc in mod asincron in ceea ce prive<?>te apelul
       pthread_cancel(); starea de retur a apelului pthread_cancel()
       informeaza doar apelantul daca cererea de anulare a fost pusa in coada
       cu succes.

       Dupa terminarea unui fir de execu<?>ie anulat, o asociere cu acel fir
       de execu<?>ie folosind pthread_join(3) ob<?>ine PTHREAD_CANCELED ca
       stare de ie<?>ire a firului de execu<?>ie; (unirea cu un fir este
       singura modalitate de a <?>ti ca anularea s-a incheiat).

VALOAREA RETURNATA
       In caz de succes, pthread_cancel() returneaza 0; in caz de eroare,
       returneaza un numar de eroare diferit de zero.

ERORI-IE<?>IRE
       ESRCH  Nu a putut fi gasit niciun fir de execu<?>ie cu identificatorul
              thread.

ATRIBUTE
       Pentru o explica<?>ie a termenilor folosi<?>i in aceasta sec<?>iune, a
       se vedea attributes(7).

       +--------------------------------------+---------------------+---------+
       |Interfa<?>a                           | Atribut             | Valoare |
       +--------------------------------------+---------------------+---------+
       |pthread_cancel()                      | Siguran<?>a firelor | MT-Safe |
       +--------------------------------------+---------------------+---------+
VERSIUNI
       In Linux, anularea este implementata utilizand semnale. In cadrul
       implementarii threading NPTL, primul semnal in timp real (adica
       semnalul 32) este utilizat in acest scop. In LinuxThreads, se
       utilizeaza al doilea semnal in timp real, daca sunt disponibile semnale
       in timp real, altfel se utilizeaza SIGUSR2.

STANDARDE
       POSIX.1-2008.

ISTORIC
       glibc 2.0 POSIX.1-2001.

EXEMPLE
       Programul de mai jos creeaza un fir <?>i apoi il anuleaza. Firul
       principal se une<?>te cu firul anulat pentru a verifica daca starea sa
       de ie<?>ire a fost PTHREAD_CANCELED. Urmatoarea sesiune shell arata ce
       se intampla atunci cand rulam programul:

           $ ./a.out
           thread_func(): pornit; anulare dezactivata
           main(): se trimite cererea de anulare
           thread_func(): privind activarea anularii
           main(): firul a fost anulat

   Sursa programului
       #include <errno.h>
       #include <pthread.h>
       #include <stdio.h>
       #include <stdlib.h>
       #include <unistd.h>

       #define handle_error_en(en, msg) \
               do { errno = en; perror(msg); exit(EXIT_FAILURE); } while (0)

       static void *
       thread_func(void *ignored_argument)
       {
           int s;

           /* Dezactiveaza anularea pentru o perioada, astfel incat
              sa nu reac<?>ionam 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 dezactivata\n", __func__);
           sleep(5);
           printf("%s(): privind activarea anularii\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 sa se anuleze in timp ce dormim */

           /* N-ar trebui sa ajunga niciodata aici. */

           printf("%s(): nu este anulat!\n", __func__);
           return NULL;
       }

       int
       main(void)
       {
           pthread_t thr;
           void *res;
           int s;

           /* Incepe un fir <?>i apoi ii trimite o cerere de anulare. */

           s = pthread_create(&thr, NULL, &thread_func, NULL);
           if (s != 0)
               handle_error_en(s, "pthread_create");

           sleep(2);           /* Da firului o <?>ansa de a incepe */

           printf("%s(): se trimite cererea de anulare\n", __func__);
           s = pthread_cancel(thr);
           if (s != 0)
               handle_error_en(s, "pthread_cancel");

           /* Se alatura 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\n", __func__);
           else
               printf("%s(): firul nu a fost anulat (nu ar trebui sa se intample!)\n",
                      __func__);
           exit(EXIT_SUCCESS);
       }

CONSULTA<?>I <?>I
       pthread_cleanup_push(3), pthread_create(3), pthread_exit(3),
       pthread_join(3), pthread_key_create(3), pthread_setcancelstate(3),
       pthread_setcanceltype(3), pthread_testcancel(3), pthreads(7)

TRADUCERE
       Traducerea in limba romana a acestui manual a fost facuta de Remus-
       Gabriel Chelu <remusgabriel.chelu@disroot.org>

       Aceasta traducere este documenta<?>ie gratuita; citi<?>i Licen<?>a
       publica generala GNU Versiunea 3
       <https://www.gnu.org/licenses/gpl-3.0.html> sau o versiune ulterioara
       cu privire la condi<?>ii privind drepturile de autor.  NU se asuma
       NICIO RESPONSABILITATE.

       Daca gasi<?>i erori in traducerea acestui manual, va rugam sa
       trimite<?>i un e-mail la <translation-team-ro@lists.sourceforge.net>.

Pagini de manual de Linux 6.12 5 noiembrie 2024              pthread_cancel(3)