pthread_setcancelstate(3)  Library Functions Manual  pthread_setcancelstate(3)

NUME
       pthread_setcancelstate, pthread_setcanceltype - stabile<?>te starea
       <?>i tipul anulabilita<?>ii

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

SINOPSIS
       #include <pthread.h>

       int pthread_setcancelstate(int state, int *oldstate);
       int pthread_setcanceltype(int type, int *oldtype);

DESCRIERE
       pthread_setcancelstate() stabile<?>te starea de anulabilitate a firului
       apelant la valoarea indicata in state. Starea anterioara de anulare a
       firului este returnata in memoria tampon indicata de oldstate.
       Argumentul state trebuie sa aiba una dintre urmatoarele valori:

       PTHREAD_CANCEL_ENABLE
              Firul este anulabil. Aceasta este starea implicita de anulare in
              toate firele noi, inclusiv in firul ini<?>ial. Tipul de
              anulabilitate al firului determina momentul in care un fir
              anulabil va raspunde la o cerere de anulare.

       PTHREAD_CANCEL_DISABLE
              Firul nu este anulabil. Daca se prime<?>te o cerere de anulare,
              acesta este blocat pana la activarea posibilita<?>ii de anulare.

       pthread_setcanceltype() stabile<?>te tipul de anulabilitate al firului
       apelant la valoarea indicata in type. Tipul anterior de anulabilitate
       al firului este returnat in memoria tampon indicata de oldtype.
       Argumentul type trebuie sa aiba una dintre urmatoarele valori:

       PTHREAD_CANCEL_DEFERRED
              O cerere de anulare este amanata pana cand firul urmator
              apeleaza o func<?>ie care este un punct de anulare (a se vedea
              pthreads(7)). Acesta este tipul implicit de anulare in toate
              firele noi, inclusiv in firul ini<?>ial.

              Chiar <?>i in cazul anularii amanate, un punct de anulare
              dintr-un gestionar de semnal asincron poate fi totu<?>i luat in
              considerare, iar efectul este ca <?>i cum ar fi fost o anulare
              asincrona.

       PTHREAD_CANCEL_ASYNCHRONOUS
              Firul poate fi anulat in orice moment; (in mod normal, acesta va
              fi anulat imediat dupa primirea unei cereri de anulare, dar
              sistemul nu garanteaza acest lucru).

       Opera<?>ia ,,set-and-get" efectuata de fiecare dintre aceste func<?>ii
       este atomica in ceea ce prive<?>te alte fire din proces care apeleaza
       la aceea<?>i func<?>ie.

VALOAREA RETURNATA
       In caz de succes, aceste func<?>ii returneaza 0; in caz de eroare, ele
       returneaza un numar de eroare diferit de zero.

ERORI-IE<?>IRE
       pthread_setcancelstate() poate e<?>ua cu urmatoarea eroare:

       EINVAL Valoare nevalida pentru state.

       pthread_setcanceltype() poate e<?>ua cu urmatoarea eroare:

       EINVAL Valoare nevalida pentru type.

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

       +--------------------------------------+---------------------+---------+
       |Interfa<?>a                           | Atribut             | Valoare |
       +--------------------------------------+---------------------+---------+
       |pthread_setcancelstate(),             | Siguran<?>a firelor | MT-Safe |
       |pthread_setcanceltype()               |                     |         |
       +--------------------------------------+---------------------+---------+
       |pthread_setcancelstate(),             | Async-cancel safety | AC-Safe |
       |pthread_setcanceltype()               |                     |         |
       +--------------------------------------+---------------------+---------+
STANDARDE
       POSIX.1-2008.

ISTORIC
       glibc 2.0 POSIX.1-2001.

NOTE
       Pentru detalii despre ce se intampla atunci cand un fir este anulat,
       consulta<?>i pthread_cancel(3).

       Dezactivarea pentru scurt timp a capacita<?>ii de anulare este utila in
       cazul in care un fir de execu<?>ie efectueaza o ac<?>iune critica care
       nu trebuie intrerupta de o cerere de anulare. Aten<?>ie la dezactivarea
       capacita<?>ii de anulare pentru perioade lungi de timp sau in jurul
       unor opera<?>ii care se pot bloca pentru perioade lungi de timp,
       deoarece acest lucru va face ca firul sa nu raspunda la cererile de
       anulare.

   Anulabilitate asincrona
       Stabilirea tipului de anulare la PTHREAD_CANCEL_ASYNCHRONOUS este
       rareori utila. Deoarece firul poate fi anulat in orice moment, acesta
       nu poate rezerva resurse in siguran<?>a (de exemplu, alocarea de
       memorie cu malloc(3)), nu poate achizi<?>iona mutex-uri, semafoare sau
       blocaje <?>i a<?>a mai departe. Rezervarea resurselor este nesigura
       deoarece aplica<?>ia nu are cum sa <?>tie care este starea acestor
       resurse atunci cand firul este anulat; adica, anularea a avut loc
       inainte ca resursele sa fie rezervate, in timp ce erau rezervate sau
       dupa ce au fost eliberate? In plus, unele structuri interne de date (de
       exemplu, lista legata a blocurilor libere gestionata de familia de
       func<?>ii malloc(3)) poate fi lasata intr-o stare inconsistenta daca
       anularea are loc in mijlocul apelului func<?>iei. In consecin<?>a,
       gestionarii de cura<?>are inceteaza sa mai fie utili.

       Func<?>iile care pot fi anulate in mod sigur in mod asincron sunt
       denumite func<?>ii asincrone de anulare sigura (async-cancel-safe).
       POSIX.1-2001 <?>i POSIX.1-2008 cer doar ca pthread_cancel(3),
       pthread_setcancelstate() <?>i pthread_setcanceltype() sa fie
       async-cancel-safe. In general, alte func<?>ii de biblioteca nu pot fi
       apelate in siguran<?>a de la un fir de execu<?>ie cu anulare asincrona.

       Una dintre pu<?>inele circumstan<?>e in care anularea asincrona este
       utila este anularea unui fir care se afla intr-o bucla legata pur de
       calcul.

   Note privind portabilitatea
       Implementarile threading Linux permit ca argumentul oldstate din
       pthread_setcancelstate() sa fie NULL, caz in care informa<?>iile despre
       starea anterioara de anulare nu sunt returnate apelantului. Multe alte
       implementari permit, de asemenea, un argument oldstat NULL, dar POSIX.1
       nu specifica acest punct, astfel incat aplica<?>iile portabile ar
       trebui sa specifice intotdeauna o valoare non-NULL in oldstate. Un set
       exact analog de declara<?>ii se aplica pentru argumentul oldtype al
       pthread_setcanceltype().

EXEMPLE
       Consulta<?>i pthread_cancel(3).

CONSULTA<?>I <?>I
       pthread_cancel(3), pthread_cleanup_push(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   23 iulie 2024       pthread_setcancelstate(3)