개요

• 솔라나라에 설명된 어플리케이션에 대해 맨 페이지를 찾아 출력한다.
• MAN 페이지에 대한 설명은 윈디하나의 솔라나라: MAN 페이지을 참고하자.
• svcadm(8)을 검색하려면 섹션에서 8 을 선택하고, 맨 페이지 이름에 svcadm을 입력하고 검색을 누른다.

pthread_rwlock_init(3c)

Standard C Library Functions                           pthread_rwlock_init(3C)



NAME
       pthread_rwlock_init,  pthread_rwlock_destroy  -  initialize  or destroy
       read-write lock object

SYNOPSIS
       #include <pthread.h>

       int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,
            const pthread_rwlockattr_t *restrict attr);


       int pthread_rwlock_destroy(pthread_rwlock_t **rwlock);


       pthread_rwlock_t rwlock=PTHREAD_RWLOCK_INITIALIZER;

DESCRIPTION
       The pthread_rwlock_init() function initializes the read-write lock ref‐
       erenced  by  rwlock  with the attributes referenced by attr. If attr is
       NULL, the default read-write lock attributes are 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 re-initialized. Upon successful initialization, the state
       of the read-write lock becomes initialized and  unlocked.  Results  are
       undefined if pthread_rwlock_init() is called specifying an already ini‐
       tialized 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 is not initialized
       and the contents of rwlock are undefined.


       The pthread_rwlock_destroy()  function  destroys  the  read-write  lock
       object  referenced  by  rwlock  and  releases any resources used by the
       lock. The effect of subsequent use of the lock is undefined  until  the
       lock  is  re-initialized  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 unde‐
       fined behaviour. A destroyed read-write lock object can be  re-initial‐
       ized  using pthread_rwlock_init(); the results of otherwise referencing
       the read-write lock object after it has been destroyed are undefined.


       In cases where default read-write lock attributes are appropriate,  the
       macro  PTHREAD_RWLOCK_INITIALIZER  can be used to initialize read-write
       locks that are  statically  allocated.  The  effect  is  equivalent  to
       dynamic  initialization  by  a  call  to pthread_rwlock_init() with the
       parameter attr specified as NULL, except that no error checks are  per‐
       formed.

RETURN VALUES
       If  successful,  the pthread_rwlock_init() and pthread_rwlock_destroy()
       functions return 0. Otherwise, an error number is returned to  indicate
       the error.

ERRORS
       The  pthread_rwlock_init()  and pthread_rwlock_destroy() functions will
       fail if:

       EINVAL    The value specified by attr is invalid.


       EINVAL    The value specified by rwlock is invalid.


       ENOMEM    Insufficient memory exists to  initialize  the  rwlock.  This
                 error  code  applies  only  to scalable rwlocks which require
                 extra memory allocation during initialization.


EXAMPLES
       Example 1 Scalable rwlock



        The following example illustrates  creation  and  destruction  of  the
       scalable read-write lock.



         #include <pthread.h>
         int
         main(int argc, char *argv[])
         {
                   int                     error;
                   pthread_rwlock_t        rwlock;
                         pthread_rwlockattr_t rwlattr;

                         error = pthread_rwlockattr_init(&rwlattr);
                   if (error != 0)
                                 return (1);

                         error = pthread_rwlockattr_settype_np(&rwlattr,
                             PTHREAD_RWLOCK_SCALABLE_NP);
                         if (error != 0)
                                 return (2);

                   error = pthread_rwlock_init(&rwlock, &rwlattr);
                   if (error != 0)
                        return (3);

                        error = pthread_rwlock_destroy(&rwlock);
                         if (error != 0)
                                 return (4);

                        error = pthread_rwlockattr_destroy(&rwlattr);
                         if (error != 0)
                                 return (5);
                         return (0);
                  }




       The  scalable  rwlock  pthread_rwlock_init() function must be called to
       initialize the lock. Static initialization cannot be done for  a  scal‐
       able  rwlock  as  it  requires extra memory allocation. Also, after the
       application is done using the scalable rwlock object, it must call  the
       pthread_rwlock_destroy()  function  to  deallocate  memory  used by the
       rwlock object to prevent memory leaks.

ATTRIBUTES
       See attributes(7) for descriptions of the following attributes:


       tab() box; cw(2.75i) |cw(2.75i) lw(2.75i) |lw(2.75i) ATTRIBUTE  TYPEAT‐
       TRIBUTE  VALUE _ Interface StabilityCommitted _ MT-LevelMT-Safe _ Stan‐
       dardSee standards(7).


SEE ALSO
       pthread_rwlock_rdlock(3C),                   pthread_rwlock_unlock(3C),
       pthread_rwlock_wrlock(3C), pthread_rwlockattr_init(3C), pthread_rwlock‐
       attr_getpshared(3C), attributes(7), standards(7)



Oracle Solaris 11.4               07 Oct 2016          pthread_rwlock_init(3C)