# pthread_rwlock_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_rwlock_destroy, pthread_rwlock_init — destroy and
           initialize a read-write lock object
    


## SYNOPSIS



           #include <pthread.h>
    
           int pthread_rwlock_destroy(pthread_rwlock_t *_rwlock_);
           int pthread_rwlock_init(pthread_rwlock_t *restrict _rwlock_ ,
               const pthread_rwlockattr_t *restrict _attr_);
           pthread_rwlock_t _rwlock_ = PTHREAD_RWLOCK_INITIALIZER;
    


## DESCRIPTION



           The _pthread_rwlock_destroy_() function shall destroy the read-write
           lock object referenced by _rwlock_ and release any resources used by
           the lock. The effect of subsequent use of the lock is undefined
           until the lock is reinitialized by another call to
           _pthread_rwlock_init_().  An implementation may cause
           _pthread_rwlock_destroy_() to set the object referenced by _rwlock_ to
           an invalid value. Results are undefined if
           _pthread_rwlock_destroy_() is called when any thread holds _rwlock_.
           Attempting to destroy an uninitialized read-write lock results in
           undefined behavior.
    
           The _pthread_rwlock_init_() function shall allocate any resources
           required to use the read-write lock referenced by _rwlock_ and
           initializes the lock to an unlocked state with attributes
           referenced by _attr_.  If _attr_ is NULL, the default read-write lock
           attributes shall be used; the effect is the same as passing the
           address of a default read-write lock attributes object. Once
           initialized, the lock can be used any number of times without
           being reinitialized. Results are undefined if
           _pthread_rwlock_init_() is called specifying an already initialized
           read-write lock. Results are undefined if a read-write lock is
           used without first being initialized.
    
           If the _pthread_rwlock_init_() function fails, _rwlock_ shall not be
           initialized and the contents of _rwlock_ are undefined.
    
           See _Section 2.9.9_ , _Synchronization Object Copies and Alternative_
           _Mappings_ for further requirements.
    
           In cases where default read-write lock attributes are appropriate,
           the macro PTHREAD_RWLOCK_INITIALIZER can be used to initialize
           read-write locks. The effect shall be equivalent to dynamic
           initialization by a call to _pthread_rwlock_init_() with the _attr_
           parameter specified as NULL, except that no error checks are
           performed.
    
           The behavior is undefined if the value specified by the _attr_
           argument to _pthread_rwlock_init_() does not refer to an initialized
           read-write lock attributes object.
    


## RETURN VALUE



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


## ERRORS



           The _pthread_rwlock_init_() function shall fail if:
    
           **EAGAIN** The system lacked the necessary resources (other than
                  memory) to initialize another read-write lock.
    
           **ENOMEM** Insufficient memory exists to initialize the read-write
                  lock.
    
           **EPERM** The caller does not have the privilege to perform the
                  operation.
    
           These functions shall not return an error code of **[EINTR]**.
    
           _The following sections are informative._
    


## EXAMPLES



           None.
    


## APPLICATION USAGE



           Applications using these and related read-write lock functions 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
           _rwlock_ argument to _pthread_rwlock_destroy_() does not refer to an
           initialized read-write lock object, it is recommended that the
           function should fail and report an **[EINVAL]** error.
    
           If an implementation detects that the value specified by the _attr_
           argument to _pthread_rwlock_init_() does not refer to an initialized
           read-write lock attributes object, it is recommended that the
           function should fail and report an **[EINVAL]** error.
    
           If an implementation detects that the value specified by the
           _rwlock_ argument to _pthread_rwlock_destroy_() or
           _pthread_rwlock_init_() refers to a locked read-write lock object,
           or detects that the value specified by the _rwlock_ argument to
           _pthread_rwlock_init_() refers to an already initialized read-write
           lock object, it is recommended that the function should fail and
           report an **[EBUSY]** error.
    


## FUTURE DIRECTIONS



           None.
    


* * *