5 rt-thread posix读写锁源码分析

posix读写锁源码分析

初始化读写锁

int pthread_rwlock_init(pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr)
{
    if (!rwlock)
        return EINVAL;
    rwlock->attr = PTHREAD_PROCESS_PRIVATE;                     ///> (1)
    pthread_mutex_init(&(rwlock->rw_mutex), NULL);              ///> (2)
    pthread_cond_init(&(rwlock->rw_condreaders), NULL);         ///> (3)
    pthread_cond_init(&(rwlock->rw_condwriters), NULL);         ///> (4)
    rwlock->rw_nwaitwriters = 0;                                ///> (5)
    rwlock->rw_nwaitreaders = 0;                                ///> (6)
    rwlock->rw_refcount = 0;                                    ///> (7)
    return 0;
}

代码段（1）：仅有那些由同一个进程创建的线程才能够处理该读写锁。
代码段（2）：初始化互斥锁。
代码段（3）：初始化读条件变量。
代码段（4）：初始化写条件变量。
代码段（5）：等待的写线程的数量。
代码段（6）：等待的读线程的数量。
代码段（7）：0: 解锁； -1: 写入者上锁； > 0 n 读者上锁

销毁读写锁

int pthread_rwlock_destroy (pthread_rwlock_t *rwlock)
{
    int result;
    if (!rwlock)
        return EINVAL;
    if (rwlock->attr == -1)                                                 
        return 0; /* rwlock is not initialized */                           ///> (1)
    if ( (result = pthread_mutex_lock(&rwlock->rw_mutex)) != 0)             ///> (2)
        return(result);
    if (rwlock->rw_refcount != 0 || rwlock->rw_nwaitreaders != 0 ||         ///> (3)
                                        rwlock->rw_nwaitwriters != 0)
    {
        result = EBUSY;
        return result;
    }
    else
    {
        /* check whether busy */
        result = zs_sem_trytake(&(rwlock->rw_condreaders.sem));             ///> (4)
        if (result == ZS_EOK)
        {
            result = zs_sem_trytake(&(rwlock->rw_condwriters.sem));         ///> (5)
            if (result == ZS_EOK)
            {
                zs_sem_release(&(rwlock->rw_condreaders.sem));              ///> (6)
                zs_sem_release(&(rwlock->rw_condwriters.sem));              ///> (7)
                pthread_cond_destroy(&rwlock->rw_condreaders);              ///> (8)
                pthread_cond_destroy(&rwlock->rw_condwriters);              ///> (9)
            }
            else
            {
                zs_sem_release(&(rwlock->rw_condreaders.sem));              ///> (10)
                result = EBUSY;
            }
        }
        else
            result = EBUSY;
    }
    pthread_mutex_unlock(&rwlock->rw_mutex);                                ///> (11)
    if (result == 0)
        pthread_mutex_destroy(&rwlock->rw_mutex);                           ///> (12)
    return result;
}

代码段（1）：读写锁没有初始化。
代码段（2）：互斥锁上锁。
代码段（3）：写入者或读者上锁；存在等待的读线程数量；存在等待的写线程数量。
代码段（4）：非阻塞方式获取读信号。
代码段（5）：非阻塞方式获取写信号。
代码段（6）：释放读信号。
代码段（7）：释放写信号。
代码段（8）：释放读写锁读操作。
代码段（9）：释放读写锁写操作。
代码段（10）：释放读写锁读操作。
代码段（11）：互斥锁解锁。
代码段（12）：销毁互斥锁。

阻塞方式对读写锁读锁定

int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock)
{
    int result;
    if (!rwlock)
        return EINVAL;
    if (rwlock->attr == -1)
        pthread_rwlock_init(rwlock, NULL);                              ///> (1)
    if ((result = pthread_mutex_lock(&rwlock->rw_mutex)) != 0)          ///> (2)
        return(result);
    /* give preference to waiting writers */
    while (rwlock->rw_refcount < 0 || rwlock->rw_nwaitwriters > 0)      ///> (3)
    {
        rwlock->rw_nwaitreaders++;                                      ///> (4)
        /* rw_mutex will be released when waiting for rw_condreaders */
        result = pthread_cond_wait(&rwlock->rw_condreaders, &rwlock->rw_mutex); ///> (5)
        /* rw_mutex should have been taken again when returned from waiting */
        rwlock->rw_nwaitreaders--;                                              ///> (6)
        if (result != 0) /* wait error */
            break;
    }
    /* another reader has a read lock */
    if (result == 0)
        rwlock->rw_refcount++;                                          ///> (7)        
    pthread_mutex_unlock(&rwlock->rw_mutex);                            ///> (8)
    return (result);
}

代码段（1）：初始化读写锁。
代码段（2）：互斥锁上锁。
代码段（3）：写入者上锁；存在等待的写入锁；
代码段（4）：等待的读锁数量加一；
代码段（5）：阻塞方式获取读写锁的读操作释放；
代码段（6）：等待的读锁数量减一；
代码段（7）：读者加一；
代码段（8）：互斥锁解锁；

非阻塞方式对读写锁读锁定

int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock)
{
    int result;
    if (!rwlock)
        return EINVAL;
    if (rwlock->attr == -1)
        pthread_rwlock_init(rwlock, NULL);
    if ((result = pthread_mutex_lock(&rwlock->rw_mutex)) != 0)
        return(result);
    if (rwlock->rw_refcount < 0 || rwlock->rw_nwaitwriters > 0)
        result = EBUSY;        /* held by a writer or waiting writers */
    else
        rwlock->rw_refcount++; /* increment count of reader locks */
    pthread_mutex_unlock(&rwlock->rw_mutex);
    return(result);
}