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 ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩ 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⟩.