# pthread_exit

## 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_exit — thread termination
    


## SYNOPSIS



           #include <pthread.h>
    
           void pthread_exit(void *_value_ptr_);
    


## DESCRIPTION



           The _pthread_exit_() function shall terminate the calling thread and
           make the value _value_ptr_ available to any successful join with the
           terminating thread. Any cancellation cleanup handlers that have
           been pushed and not yet popped shall be popped in the reverse
           order that they were pushed and then executed. After all
           cancellation cleanup handlers have been executed, if the thread
           has any thread-specific data, appropriate destructor functions
           shall be called in an unspecified order. Thread termination does
           not release any application visible process resources, including,
           but not limited to, mutexes and file descriptors, nor does it
           perform any process-level cleanup actions, including, but not
           limited to, calling any _atexit_() routines that may exist.
    
           An implicit call to _pthread_exit_() is made when a thread other
           than the thread in which _main_() was first invoked returns from the
           start routine that was used to create it. The function's return
           value shall serve as the thread's exit status.
    
           The behavior of _pthread_exit_() is undefined if called from a
           cancellation cleanup handler or destructor function that was
           invoked as a result of either an implicit or explicit call to
           _pthread_exit_().
    
           After a thread has terminated, the result of access to local
           (auto) variables of the thread is undefined. Thus, references to
           local variables of the exiting thread should not be used for the
           _pthread_exit_() _value_ptr_ parameter value.
    
           The process shall exit with an exit status of 0 after the last
           thread has been terminated. The behavior shall be as if the
           implementation called _exit_() with a zero argument at thread
           termination time.
    


## RETURN VALUE



           The _pthread_exit_() function cannot return to its caller.
    


## ERRORS



           No errors are defined.
    
           _The following sections are informative._
    


## EXAMPLES



           None.
    


## APPLICATION USAGE



           None.
    


## RATIONALE



           The normal mechanism by which a thread terminates is to return
           from the routine that was specified in the _pthread_create_() call
           that started it. The _pthread_exit_() function provides the
           capability for a thread to terminate without requiring a return
           from the start routine of that thread, thereby providing a
           function analogous to _exit_().
    
           Regardless of the method of thread termination, any cancellation
           cleanup handlers that have been pushed and not yet popped are
           executed, and the destructors for any existing thread-specific
           data are executed. This volume of POSIX.1‐2017 requires that
           cancellation cleanup handlers be popped and called in order. After
           all cancellation cleanup handlers have been executed, thread-
           specific data destructors are called, in an unspecified order, for
           each item of thread-specific data that exists in the thread. This
           ordering is necessary because cancellation cleanup handlers may
           rely on thread-specific data.
    
           As the meaning of the status is determined by the application
           (except when the thread has been canceled, in which case it is
           PTHREAD_CANCELED), the implementation has no idea what an illegal
           status value is, which is why no address error checking is done.
    


## FUTURE DIRECTIONS



           None.
    


* * *