NUME

       pthread_spin_init, pthread_spin_destroy - inițializează sau distruge un blocaj de rotație

BIBLIOTECA

       Biblioteca de fire de execuție POSIX (libpthread, -lpthread)

REZUMAT

       #include <pthread.h>

       int pthread_spin_init(pthread_spinlock_t *lock, int pshared);
       int pthread_spin_destroy(pthread_spinlock_t *lock);

   Cerințe pentru macrocomenzi de testare a caracteristicilor pentru glibc (consultați feature_test_macros(7)):

       pthread_spin_init(), pthread_spin_destroy():
           _POSIX_C_SOURCE >= 200112L

DESCRIERE

       Nota  generală:  Majoritatea  programelor  ar trebui să utilizeze mutex-uri în loc de blocaje de rotație.
       Blocajele rotative sunt utile în primul rând în combinație cu politicile de planificare în timp  real.  A
       se vedea NOTE.

       Funcția  pthread_spin_init()  alocă  toate  resursele necesare pentru utilizarea blocării prin rotație la
       care face referire lock și inițializează blocarea pentru a fi  în  stare  deblocată.  Argumentul  pshared
       trebuie să aibă una dintre următoarele valori:

       PTHREAD_PROCESS_PRIVATE
              Blocajul  de  rotație  trebuie  să  fie  operat  numai de fire din același proces ca și firul care
              apelează pthread_spin_init(); (încercarea de a împărți blocajul de rotație între procese  duce  la
              un comportament nedefinit).

       PTHREAD_PROCESS_SHARED
              Blocajul  de  rotație poate fi operat de orice fir din orice proces care are acces la memoria care
              conține blocajul (de exemplu, blocajul poate fi într-un obiect  de  memorie  partajată  care  este
              partajat între mai multe procese).

       Apelarea  pthread_spin_init()  pe  un  blocaj  de rotație care a fost deja inițializat are ca rezultat un
       comportament nedefinit.

       Funcția pthread_spin_destroy() distruge un  blocaj  de  rotație  inițializat  anterior,  eliberând  toate
       resursele  care  au  fost  alocate  pentru acel blocaj. Distrugerea unui blocaj de rotație care nu a fost
       inițializat anterior sau distrugerea unui blocaj de rotație în timp ce un  alt  fir  de  execuție  deține
       blocajul are ca rezultat un comportament nedefinit.

       Odată  ce un blocaj de rotație a fost distrus, efectuarea oricărei operații asupra blocajului în afară de
       inițializarea acestuia cu pthread_spin_init() duce la un comportament nedefinit.

       Rezultatul   efectuării   unor   operații   precum   pthread_spin_lock(3),   pthread_spin_unlock(3)    și
       pthread_spin_destroy() pe copii ale obiectului la care se face referire prin lock este nedefinit.

VALOAREA RETURNATĂ

       În caz de succes, aceste funcții returnează zero.  În caz de eșec, acestea returnează un număr de eroare.
       În cazul în care pthread_spin_init() eșuează, blocajul nu este inițializat.

ERORI

       pthread_spin_init() poate eșua cu următoarele erori:

       EAGAIN Sistemul nu dispune de resurse suficiente pentru a inițializa un nou blocaj de rotație.

       ENOMEM Memorie insuficientă pentru a inițializa blocajul de rotire.

VERSIUNI

       Aceste funcții au fost adăugate în glibc 2.2.

STANDARDE

       POSIX.1-2001.

       Suportul  pentru  blocajele de rotație partajate de proces este o opțiune POSIX.  Opțiunea este acceptată
       în implementarea glibc.

NOTE

       Blocajele de rotație trebuie utilizate împreună cu politicile de planificare  în  timp  real  (SCHED_FIFO
       sau,  eventual, SCHED_RR). Utilizarea de blocaje de rotire cu politici de planificare nedeterministe, cum
       ar fi SCHED_OTHER, indică probabil o greșeală de proiectare. Problema constă în faptul că,  dacă  un  fir
       care  funcționează  în conformitate cu o astfel de politică este programat în afara CPU în timp ce deține
       un blocaj de rotire, atunci alte fire vor  pierde  timp  cu  rotirea  pe  blocaj  până  când  deținătorul
       blocajului este reprogramat din nou și eliberează blocajul.

       Dacă firele de execuție creează o situație de blocaj în timp ce utilizează blocaje de rotire, aceste fire
       de execuție se vor roti la nesfârșit, consumând timp de procesor.

       Blocajele  de  rotație  din  spațiul  utilizatorului  nu  sunt aplicabile ca soluție generală de blocare.
       Acestea sunt, prin definiție, predispuse la inversarea priorităților și la timpi de  rotație  nelimitați.
       Un  programator  care utilizează blocaje de rotație trebuie să fie extrem de atent nu numai la cod, ci și
       în ceea ce privește configurația sistemului, plasarea firelor și atribuirea priorităților.

CONSULTAȚI ȘI

       pthread_mutex_init(3), pthread_mutex_lock(3), pthread_spin_lock(3), pthread_spin_unlock(3), pthreads(7)

TRADUCERE

       Traducerea în limba română a acestui manual a fost creată de Remus-Gabriel Chelu
       <remusgabriel.chelu@disroot.org>

       Această traducere este documentație gratuită; citiți Licența publică generală GNU Versiunea 3 sau o
       versiune ulterioară cu privire la condiții privind drepturile de autor.  NU se asumă Nicio
       RESPONSABILITATE.

       Dacă găsiți erori în traducerea acestui manual, vă rugăm să trimiteți un e-mail la translation-team-
       ro@lists.sourceforge.net.

Pagini de manual de Linux 6.03                  4 decembrie 2022                            pthread_spin_init(3)