# pthread_detach

## 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_detach — detach a thread
    


## SYNOPSIS



           #include <pthread.h>
    
           int pthread_detach(pthread_t _thread_);
    


## DESCRIPTION



           The _pthread_detach_() function shall indicate to the implementation
           that storage for the thread _thread_ can be reclaimed when that
           thread terminates. If _thread_ has not terminated, _pthread_detach_()
           shall not cause it to terminate.
    
           The behavior is undefined if the value specified by the _thread_
           argument to _pthread_detach_() does not refer to a joinable thread.
    


## RETURN VALUE



           If the call succeeds, _pthread_detach_() shall return 0; otherwise,
           an error number shall be returned to indicate the error.
    


## ERRORS



           The _pthread_detach_() function shall not return an error code of
           **[EINTR]**.
    
           _The following sections are informative._
    


## EXAMPLES



           None.
    


## APPLICATION USAGE



           None.
    


## RATIONALE



           The _pthread_join_() or _pthread_detach_() functions should eventually
           be called for every thread that is created so that storage
           associated with the thread may be reclaimed.
    
           It has been suggested that a ``detach'' function is not necessary;
           the _detachstate_ thread creation attribute is sufficient, since a
           thread need never be dynamically detached. However, need arises in
           at least two cases:
    
            1. In a cancellation handler for a _pthread_join_() it is nearly
               essential to have a _pthread_detach_() function in order to
               detach the thread on which _pthread_join_() was waiting. Without
               it, it would be necessary to have the handler do another
               _pthread_join_() to attempt to detach the thread, which would
               both delay the cancellation processing for an unbounded period
               and introduce a new call to _pthread_join_(), which might itself
               need a cancellation handler. A dynamic detach is nearly
               essential in this case.
    
            2. In order to detach the ``initial thread'' (as may be desirable
               in processes that set up server threads).
    
           If an implementation detects that the value specified by the
           _thread_ argument to _pthread_detach_() does not refer to a joinable
           thread, it is recommended that the function should fail and report
           an **[EINVAL]** error.
    
           If an implementation detects use of a thread ID after the end of
           its lifetime, it is recommended that the function should fail and
           report an **[ESRCH]** error.
    


## FUTURE DIRECTIONS



           None.
    


* * *