# pthread_cond_destroy

## 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_cond_destroy, pthread_cond_init — destroy and initialize
           condition variables
    


## SYNOPSIS



           #include <pthread.h>
    
           int pthread_cond_destroy(pthread_cond_t *_cond_);
           int pthread_cond_init(pthread_cond_t *restrict _cond_ ,
               const pthread_condattr_t *restrict _attr_);
           pthread_cond_t _cond_ = PTHREAD_COND_INITIALIZER;
    


## DESCRIPTION



           The _pthread_cond_destroy_() function shall destroy the given
           condition variable specified by _cond_ ; the object becomes, in
           effect, uninitialized. An implementation may cause
           _pthread_cond_destroy_() to set the object referenced by _cond_ to an
           invalid value. A destroyed condition variable object can be
           reinitialized using _pthread_cond_init_(); the results of otherwise
           referencing the object after it has been destroyed are undefined.
    
           It shall be safe to destroy an initialized condition variable upon
           which no threads are currently blocked. Attempting to destroy a
           condition variable upon which other threads are currently blocked
           results in undefined behavior.
    
           The _pthread_cond_init_() function shall initialize the condition
           variable referenced by _cond_ with attributes referenced by _attr_.
           If _attr_ is NULL, the default condition variable attributes shall
           be used; the effect is the same as passing the address of a
           default condition variable attributes object. Upon successful
           initialization, the state of the condition variable shall become
           initialized.
    
           See _Section 2.9.9_ , _Synchronization Object Copies and Alternative_
           _Mappings_ for further requirements.
    
           Attempting to initialize an already initialized condition variable
           results in undefined behavior.
    
           In cases where default condition variable attributes are
           appropriate, the macro PTHREAD_COND_INITIALIZER can be used to
           initialize condition variables. The effect shall be equivalent to
           dynamic initialization by a call to _pthread_cond_init_() with
           parameter _attr_ specified as NULL, except that no error checks are
           performed.
    
           The behavior is undefined if the value specified by the _cond_
           argument to _pthread_cond_destroy_() does not refer to an
           initialized condition variable.
    
           The behavior is undefined if the value specified by the _attr_
           argument to _pthread_cond_init_() does not refer to an initialized
           condition variable attributes object.
    


## RETURN VALUE



           If successful, the _pthread_cond_destroy_() and _pthread_cond_init_()
           functions shall return zero; otherwise, an error number shall be
           returned to indicate the error.
    


## ERRORS



           The _pthread_cond_init_() function shall fail if:
    
           **EAGAIN** The system lacked the necessary resources (other than
                  memory) to initialize another condition variable.
    
           **ENOMEM** Insufficient memory exists to initialize the condition
                  variable.
    
           These functions shall not return an error code of **[EINTR]**.
    
           _The following sections are informative._
    


## EXAMPLES



           A condition variable can be destroyed immediately after all the
           threads that are blocked on it are awakened. For example, consider
           the following code:
    
               struct list {
                   pthread_mutex_t lm;
                   ...
               }
    
               struct elt {
                   key k;
                   int busy;
                   pthread_cond_t notbusy;
                   ...
               }
    
               /* Find a list element and reserve it. */
               struct elt *
               list_find(struct list *lp, key k)
               {
                   struct elt *ep;
    
                   pthread_mutex_lock(&lp->lm);
                   while ((ep = find_elt(l, k) != NULL) && ep->busy)
                       pthread_cond_wait(&ep->notbusy, &lp->lm);
                   if (ep != NULL)
                       ep->busy = 1;
                   pthread_mutex_unlock(&lp->lm);
                   return(ep);
               }
    
               delete_elt(struct list *lp, struct elt *ep)
               {
                   pthread_mutex_lock(&lp->lm);
                   assert(ep->busy);
                   ... remove ep from list ...
                   ep->busy = 0;  /* Paranoid. */
               (A) pthread_cond_broadcast(&ep->notbusy);
                   pthread_mutex_unlock(&lp->lm);
               (B) pthread_cond_destroy(&ep->notbusy);
                   free(ep);
               }
    
           In this example, the condition variable and its list element may
           be freed (line B) immediately after all threads waiting for it are
           awakened (line A), since the mutex and the code ensure that no
           other thread can touch the element to be deleted.
    


## APPLICATION USAGE



           None.
    


## RATIONALE



           If an implementation detects that the value specified by the _cond_
           argument to _pthread_cond_destroy_() does not refer to an
           initialized condition variable, it is recommended that the
           function should fail and report an **[EINVAL]** error.
    
           If an implementation detects that the value specified by the _cond_
           argument to _pthread_cond_destroy_() or _pthread_cond_init_() refers
           to a condition variable that is in use (for example, in a
           _pthread_cond_wait_() call) by another thread, or detects that the
           value specified by the _cond_ argument to _pthread_cond_init_() refers
           to an already initialized condition variable, it is recommended
           that the function should fail and report an **[EBUSY]** error.
    
           If an implementation detects that the value specified by the _attr_
           argument to _pthread_cond_init_() does not refer to an initialized
           condition variable attributes object, it is recommended that the
           function should fail and report an **[EINVAL]** error.
    
           See also pthread_mutex_destroy(3p).
    


## FUTURE DIRECTIONS



           None.
    


* * *