POSIX之Reader-Writer Lock

/*
 * 分配读写锁的资源，使用pAttr初始化为unlocked状态 
 * 如果pAttr为NULL，则使用默认属性
 */
int pthread_rwlock_init(pthread_rwlock_t *pRwlock, pthread_rwlockattr_t *pAttr);
/* 销毁读写锁，释放其资源 */
int pthread_rwlock_destroy(pthread_rwlock_t *pRwlock);

/* Vx7 RTP */
typedef struct
    {
    int          rwlockAttrStatus;
    int          rwlockAttrPshared;
    unsigned int rwlockAttrMaxReaders;
    unsigned int rwlockAttrConformOpt;
    }pthread_rwlockattr_t;

/*
 * rwlockAttrStatus
 *   PTHREAD_INITIALIZED_OBJ - 默认值
 *   PTHREAD_DESTROYED_OBJ
 */
int pthread_rwlockattr_init(pthread_rwlockattr_t *pAttr);
int pthread_rwlockattr_destroy(pthread_rwlockattr_t *pAttr);
/*
 * rwlockAttrPshared
 *   PTHREAD_PROCESS_PRIVATE - 默认值
 *   PTHREAD_PROCESS_SHARED
 */
int pthread_rwlockattr_getpshared(pthread_rwlockattr_t *pAttr, int *pShared);
int pthread_rwlockattr_setpshared(pthread_rwlockattr_t *pAttr, int shared);
/*
 * rwlockAttrMaxReaders
 *   SEM_RW_MAX_CONCURRENT_READERS - 默认值，也是最大值
 */
int pthread_rwlockattr_setmaxreaders(pthread_rwlockattr_t *pAttr, unsigned int maxNumReaders);
/*
 * rwlockAttrConformOpt
 *   1 - 默认值
 *   0 - 表示允许Writer多次write lock读写锁
 */
int pthread_rwlockattr_setconformance(pthread_rwlockattr_t *pAttr, unsigned int confVar);

/*
 * 给pRwlock上锁，用于reading
 * 如果没有writer，给pRwlock加一个read lock，否则阻塞 
 * 如果当前Thread已经持有read lock，可以再次lock，但要unlock同样次数 
 * 如果read lock已经达到上限，则返回EAGAIN 
 * 如果当前Thread已经持有write lock，返回EDEADLK
 */
int pthread_rwlock_rdlock(pthread_rwlockpRwlock_t *pRwlock);
/*
 * 类似于pthread_rwlock_rdlock()
 * 但有write lock，或writer阻塞时，直接返回EBUSY
 */
int pthread_rwlock_tryrdlock(pthread_rwlock_t *pRwlock);
/*
 * 类似于pthread_rwlock_rdlock()
 * 但阻塞到绝对时间pAbstime时，返回ETIMEDOUT
 */
int pthread_rwlock_timedrdlock(pthread_rwlock_t *pRwlock, struct timespec *pAbstime); 
/*
 * 给pRwlock上锁，用于writing
 * 如果pRwlock空闲，给pRwlock加一个write lock，否则阻塞 
 * 如果当前Thread已经持有read lock，返回EDEADLK
 * 如果当前Thread已经持有write lock，且rwlockAttrConformOpt为1，返回EDEADLK
 * 如果当前Thread已经持有write lock，且rwlockAttrConformOpt为0，则上锁成功，但要解锁同样次数
 */
int pthread_rwlock_wrlock(pthread_rwlock_t *pRwlock);
/*
 * 类似于pthread_rwlock_wrlock()
 * 但不同于pthread_rwlock_wrlock()的阻塞，而是直接返回EBUSY
 */
int pthread_rwlock_trywrlock(pthread_rwlock_t *pRwlock);
/*
 * 类似于pthread_rwlock_wrlock()
 * 但阻塞到绝对时间pAbstime时，返回ETIMEDOUT
 */
int pthread_rwlock_timedwrlock(pthread_rwlock_t *pRwlock, struct timespec *pAbstime); 
/*
 * 解锁当前Thread之前lock的pRwlock
 *
 * 如果释放的是read锁，而该锁还被其它Thread以read锁方式持有，则该锁保持read锁的锁定状态 
 * 如果释放的是最后一个read锁，则置为未锁定状态 
 *
 * 如果释放的是write锁，则置为未锁定状态
 * 当有write锁和read锁同时阻塞在该锁上时，write锁优先
 * 当有多个write锁或只有多个read锁时，优先级最高者优先
 */
int pthread_rwlock_unlock(pthread_rwlock_t *pRwlock);

/*
 * 版权所有  公众号  VxWorks567
 * Vx7 RTP
 */

#include <stdio.h>    /* printf() */
#include <unistd.h>   /* sleep() */
#include <pthread.h>  /* pthread_create() */

static pthread_rwlock_t rwlockid;

static void *thread1(void *arg)
{
    int ret;

    printf("POSIX RWLOCK: in thread1, pthread_rwlock_rdlock begin\n");
    ret = pthread_rwlock_rdlock (&rwlockid);
    printf("POSIX RWLOCK: in thread1, pthread_rwlock_rdlock end\n\n");
    sleep(2);
    printf("POSIX RWLOCK: in thread1, pthread_rwlock_unlock begin\n");
    ret = pthread_rwlock_unlock (&rwlockid);
    printf("POSIX RWLOCK: in thread1, pthread_rwlock_unlock end\n");

    sleep(1);

    /* #define EBUSY   16  Device or resource busy */
    printf("POSIX RWLOCK: in thread1, pthread_rwlock_tryrdlock begin\n");
    ret = pthread_rwlock_tryrdlock (&rwlockid);
    printf("POSIX RWLOCK: in thread1, pthread_rwlock_tryrdlock end, ret=%d\n", ret);

    printf("POSIX RWLOCK: in thread1, pthread_rwlock_rdlock begin\n\n");
    ret = pthread_rwlock_rdlock (&rwlockid);
    printf("POSIX RWLOCK: in thread1, pthread_rwlock_rdlock end\n");

    printf("POSIX RWLOCK: in thread1, pthread_rwlock_unlock begin\n");
    ret = pthread_rwlock_unlock (&rwlockid);
    printf("POSIX RWLOCK: in thread1, pthread_rwlock_unlock end\n");
    return NULL;
    }
    
static void *thread2(void *arg)
{
    int ret;

    sleep(1);
    printf("POSIX RWLOCK: in thread2, pthread_rwlock_rdlock begin\n");
    ret = pthread_rwlock_rdlock (&rwlockid);
    printf("POSIX RWLOCK: in thread2, pthread_rwlock_rdlock end\n");

    printf("POSIX RWLOCK: in thread2, pthread_rwlock_unlock begin\n");
    ret = pthread_rwlock_unlock (&rwlockid);
    printf("POSIX RWLOCK: in thread2, pthread_rwlock_unlock end\n");

#if 0 /* #define EBUSY   16  Device or resource busy */
    printf("POSIX RWLOCK: in thread2, pthread_rwlock_rdlock begin\n");
    ret = pthread_rwlock_rdlock (&rwlockid);
    printf("POSIX RWLOCK: in thread2, pthread_rwlock_rdlock end\n");

    printf("POSIX RWLOCK: in thread2, pthread_rwlock_trywrlock begin\n\n");
    ret = pthread_rwlock_trywrlock (&rwlockid);
    printf("POSIX RWLOCK: in thread2, pthread_rwlock_trywrlock end, ret=%d\n", ret);
#endif

    printf("POSIX RWLOCK: in thread2, pthread_rwlock_wrlock begin\n\n");
    ret = pthread_rwlock_wrlock (&rwlockid);
    printf("POSIX RWLOCK: in thread2, pthread_rwlock_wrlock end, ret=%d\n\n", ret);

#if 0 /* #define EDEADLK 35 Resource deadlock would occur */
    printf("POSIX RWLOCK: in thread2, pthread_rwlock_rdlock begin\n");
    ret = pthread_rwlock_rdlock (&rwlockid);
    printf("POSIX RWLOCK: in thread2, pthread_rwlock_rdlock end, ret=%d\n", ret);
#endif

    sleep(2);
    printf("POSIX RWLOCK: in thread2, pthread_rwlock_unlock begin\n");
    ret = pthread_rwlock_unlock (&rwlockid);
    printf("POSIX RWLOCK: in thread2, pthread_rwlock_unlock end\n");
    return NULL;
    }

int main()
{
    pthread_t tid1;
    pthread_t tid2;
    int ret;

    ret = pthread_rwlock_init (&rwlockid, NULL);
    printf("POSIX RWLOCK: in thread0, pthread_rwlock_init\n");

    ret = pthread_create(&tid1, NULL, &thread1, NULL);
    ret = pthread_create(&tid2, NULL, &thread2, NULL);
    ret = pthread_join(tid1, NULL);
    ret = pthread_join(tid2, NULL);

    ret = pthread_rwlock_destroy (&rwlockid);
    printf("POSIX RWLOCK: in thread0, pthread_rwlock_destroy\n");
    return 0;
    }