개요

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

pthread_rwlock_init(3c)

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 ob‐
       ject 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 implementa‐
       tion may cause pthread_rwlock_destroy() to set the object referenced by
       rwlock to an invalid value. Results are undefined if pthread_rwlock_de‐
       stroy()  is  called when any thread holds rwlock. Attempting to destroy
       an uninitialized read-write lock results in undefined behaviour. A  de‐
       stroyed   read-write   lock   object   can   be   re-initialized  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 dy‐
       namic initialization by a call to pthread_rwlock_init() with the  para‐
       meter  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 er‐
                 ror 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 scal‐
       able 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 ap‐
       plication  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)