# pthread_barrier_wait

## PROLOG



           This manual page is part of the POSIX Programmer's Manual.  The
           Linux implementation of this interface may differ (consult the
           corresponding Linux manual page for details of Linux behavior), or
           the interface may not be implemented on Linux.
    


## NAME



           pthread_barrier_wait — synchronize at a barrier
    


## SYNOPSIS



           #include <pthread.h>
    
           int pthread_barrier_wait(pthread_barrier_t *_barrier_);
    


## DESCRIPTION



           The _pthread_barrier_wait_() function shall synchronize
           participating threads at the barrier referenced by _barrier_.  The
           calling thread shall block until the required number of threads
           have called _pthread_barrier_wait_() specifying the barrier.
    
           When the required number of threads have called
           _pthread_barrier_wait_() specifying the barrier, the constant
           PTHREAD_BARRIER_SERIAL_THREAD shall be returned to one unspecified
           thread and zero shall be returned to each of the remaining
           threads. At this point, the barrier shall be reset to the state it
           had as a result of the most recent _pthread_barrier_init_() function
           that referenced it.
    
           The constant PTHREAD_BARRIER_SERIAL_THREAD is defined in
           _< pthread.h>_ and its value shall be distinct from any other value
           returned by _pthread_barrier_wait_().
    
           The results are undefined if this function is called with an
           uninitialized barrier.
    
           If a signal is delivered to a thread blocked on a barrier, upon
           return from the signal handler the thread shall resume waiting at
           the barrier if the barrier wait has not completed (that is, if the
           required number of threads have not arrived at the barrier during
           the execution of the signal handler); otherwise, the thread shall
           continue as normal from the completed barrier wait. Until the
           thread in the signal handler returns from it, it is unspecified
           whether other threads may proceed past the barrier once they have
           all reached it.
    
           A thread that has blocked on a barrier shall not prevent any
           unblocked thread that is eligible to use the same processing
           resources from eventually making forward progress in its
           execution. Eligibility for processing resources shall be
           determined by the scheduling policy.
    


## RETURN VALUE



           Upon successful completion, the _pthread_barrier_wait_() function
           shall return PTHREAD_BARRIER_SERIAL_THREAD for a single
           (arbitrary) thread synchronized at the barrier and zero for each
           of the other threads. Otherwise, an error number shall be returned
           to indicate the error.
    


## ERRORS



           This function shall not return an error code of **[EINTR]**.
    
           _The following sections are informative._
    


## EXAMPLES



           None.
    


## APPLICATION USAGE



           Applications using this function may be subject to priority
           inversion, as discussed in the Base Definitions volume of
           POSIX.1‐2017, _Section 3.291_ , _Priority Inversion_.
    


## RATIONALE



           If an implementation detects that the value specified by the
           _barrier_ argument to _pthread_barrier_wait_() does not refer to an
           initialized barrier object, it is recommended that the function
           should fail and report an **[EINVAL]** error.
    


## FUTURE DIRECTIONS



           None.
    


* * *