sem_wait(3)                Library Functions Manual                sem_wait(3)

NUME
       sem_wait, sem_timedwait, sem_trywait - blocheaza un semafor

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

SINOPSIS
       #include <semaphore.h>

       int sem_wait(sem_t *sem);
       int sem_trywait(sem_t *sem);
       int sem_timedwait(sem_t *restrict sem,
                         const struct timespec *restrict abs_timeout);

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

       sem_timedwait():
           _POSIX_C_SOURCE >= 200112L

DESCRIERE
       sem_wait() decrementeaza (blocheaza) semaforul indicat de sem. In cazul
       in care valoarea semaforului este mai mare decat zero, atunci
       decrementarea are loc, iar func<?>ia returneaza, imediat. In cazul in
       care semaforul are in prezent valoarea zero, apelul se blocheaza pana
       cand fie devine posibila efectuarea decrementarii (de exemplu, valoarea
       semaforului cre<?>te peste zero), fie un gestionar de semnal intrerupe
       apelul.

       sem_trywait() este la fel ca sem_wait(), cu excep<?>ia faptului ca,
       daca decrementarea nu poate fi efectuata imediat, apelul returneaza o
       eroare (errno este configurata la EAGAIN) in loc sa blocheze.

       sem_timedwait() este la fel ca sem_wait(), cu excep<?>ia faptului ca
       abs_timeout specifica o limita de timp in care apelul trebuie blocat
       daca decrementarea nu poate fi efectuata imediat.  Argumentul
       abs_timeout indica o structura timespec(3) care specifica un timp de
       a<?>teptare absolut in secunde <?>i nanosecunde de la Epoch, 1970-01-01
       00:00:00 +0000 (UTC).

       Daca timpul de a<?>teptare a expirat deja in momentul apelului, iar
       semaforul nu a putut fi blocat imediat, atunci sem_timedwait()
       e<?>ueaza cu o eroare de timp (errno este configurata la ETIMEDOUT).

       Daca opera<?>ia poate fi efectuata imediat, atunci sem_timedwait() nu
       e<?>ueaza niciodata cu o eroare de timp de a<?>teptare, indiferent de
       valoarea lui abs_timeout. In plus, validitatea lui abs_timeout nu este
       verificata in acest caz.

VALOAREA RETURNATA
       Toate aceste func<?>ii returneaza 0 in caz de succes; in caz de eroare,
       valoarea semaforului ramane neschimbata, se returneaza -1, iar errno
       este configurata pentru a indica eroarea.

ERORI-IE<?>IRE
       EAGAIN (sem_trywait()) Opera<?>ia nu a putut fi efectuata fara blocare
              (de exemplu, semaforul are in prezent valoarea zero).

       EINTR  Apelul a fost intrerupt de un gestionar de semnal; a se vedea
              signal(7).

       EINVAL semafor nu este un semafor valid.

       EINVAL (sem_timedwait()) Valoarea abs_timeout.tv_nsecs este mai mica
              decat 0 sau mai mare sau egala cu 1000 de milioane.

       ETIMEDOUT
              (sem_timedwait()) Apelul a expirat inainte ca semaforul sa poata
              fi blocat.

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

       +--------------------------------------+---------------------+---------+
       |Interfa<?>a                           | Atribut             | Valoare |
       +--------------------------------------+---------------------+---------+
       |sem_wait(), sem_trywait(),            | Siguran<?>a firelor | MT-Safe |
       |sem_timedwait()                       |                     |         |
       +--------------------------------------+---------------------+---------+
STANDARDE
       POSIX.1-2008.

ISTORIC
       POSIX.1-2001.

EXEMPLE
       Programul (oarecum trivial) prezentat mai jos opereaza pe un semafor
       fara nume. Programul a<?>teapta doua argumente in linia de comanda.
       Primul argument specifica o valoare in secunde care este utilizata
       pentru a configura un temporizator de alarma pentru a genera un semnal
       SIGALRM. Acest gestionar efectueaza un sem_post(3) pentru a incrementa
       semaforul care este a<?>teptat in main() utilizand sem_timedwait(). Al
       doilea argument din linia de comanda specifica lungimea timpului de
       a<?>teptare, in secunde, pentru sem_timedwait(). Ceea ce urmeaza arata
       ce se intampla la doua execu<?>ii diferite ale programului:

           $ ./a.out 2 3
           In curs de apelare a sem_timedwait()
           sem_post() de la gestionar
           sem_timedwait() a reu<?>it
           $ ./a.out 2 1
           In curs de apelare a sem_timedwait()
           ssem_timedwait() a expirat

   Sursa programului
       #include <err.h>
       #include <errno.h>
       #include <semaphore.h>
       #include <signal.h>
       #include <stdio.h>
       #include <stdlib.h>
       #include <time.h>
       #include <unistd.h>

       #include <assert.h>

       sem_t sem;

       static void
       handler(int sig)
       {
           write(STDOUT_FILENO, "sem_post() de la gestionar\n", 24);
           if (sem_post(&sem) == -1) {
               write(STDERR_FILENO, "sem_post() a e<?>uat\n", 18);
               _exit(EXIT_FAILURE);
           }
       }

       int
       main(int argc, char *argv[])
       {
           struct sigaction sa;
           struct timespec ts;
           int s;

           if (argc != 3) {
               fprintf(stderr, "Utilizare: %s <secunde-alarma> <secunde-a<?>teptare>\n",
                       argv[0]);
               exit(EXIT_FAILURE);
           }

           if (sem_init(&sem, 0, 0) == -1)
               err(EXIT_FAILURE, "sem_init");

           /* Stabile<?>te gestionarul SIGALRM; fixeaza temporizatorul de alarma utilizand argv[1]. */

           sa.sa_handler = handler;
           sigemptyset(&sa.sa_mask);
           sa.sa_flags = 0;
           if (sigaction(SIGALRM, &sa, NULL) == -1)
               err(EXIT_FAILURE, "sigaction");

           alarm(atoi(argv[1]));

           /* Calculeaza intervalul relativ ca timp curent plus
              numarul de secunde dat de argv[2]. */

           if (clock_gettime(CLOCK_REALTIME, &ts) == -1)
               herr(EXIT_FAILURE, "clock_gettime");

           ts.tv_sec += atoi(argv[2]);

           printf("%s() pe cale sa apeleze sem_timedwait()\n", __func__);
           while ((s = sem_timedwait(&sem, &ts)) == -1 && errno == EINTR)
               continue;       /* Reporne<?>te daca este intrerupt de gestionar. */

           /* Verifica ce s-a intamplat. */

           if (s == -1) {
               if (errno == ETIMEDOUT)
                   printf("sem_timedwait() timed out\n");
               else
                   perror("sem_timedwait");
           } else
               printf("sem_timedwait() a reu<?>it\n");

           exit((s == 0) ? EXIT_SUCCESS : EXIT_FAILURE);
       }

CONSULTA<?>I <?>I
       clock_gettime(2), sem_getvalue(3), sem_post(3), timespec(3),
       sem_overview(7), time(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.18 8 februarie 2026                    sem_wait(3)