Linux 同步机制：读写锁

读写锁 读共享写独占

读写锁也叫 shared-exclusive 锁, 也是一种同步机制。读写锁有三种状态：读模式下加锁，写模式下加锁，不加锁。有如下的使用约定：

• 不加锁或者读模式加锁状态时，任何线程都可以读模式枷锁，但是写模式加锁会被阻塞；
• 不加锁状态时，才可以进行写模式加锁；
• 读模式加锁状态时，有线程进行写加锁，读写锁会阻塞后面的读加锁，防止试图进行写加锁的线程由于得不到锁而长期阻塞；

读模式共享，写模式独占，适合读频率远大于写频率的场景。

Linux下读写锁API

这些API位于 pthread.h 下。

init与destory

/* Initialize read-write lock RWLOCK using attributes ATTR, or use
   the default values if later is NULL.  */
extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
                                const pthread_rwlockattr_t *__restrict
                                __attr) __THROW __nonnull ((1));

/* Destroy read-write lock RWLOCK.  */
extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock)
     __THROW __nonnull ((1));

/* Initialize attribute object ATTR with default values.  */
extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr)
     __THROW __nonnull ((1));

/* Destroy attribute object ATTR.  */
extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr)
     __THROW __nonnull ((1));

阻塞模式加锁

/* Acquire read lock for RWLOCK.  */
extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock)
     __THROWNL __nonnull ((1));

/* Acquire write lock for RWLOCK.  */
extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock)
     __THROWNL __nonnull ((1));

非阻塞模式加锁

非阻塞模式加锁，接口中含try，如果未获取到，不阻塞线程，返回非零错误码。被占用是EBUSY, 可参考 Linux man：pthread_rwlock_tryrdlock。

/* Try to acquire read lock for RWLOCK.  */
extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)
  __THROWNL __nonnull ((1));

/* Try to acquire write lock for RWLOCK.  */
extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock)
     __THROWNL __nonnull ((1));

解锁

/* Unlock RWLOCK.  */
extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock)
     __THROWNL __nonnull ((1));

举例

编译的时候记得连接pthread，gcc main.c -lpthread

#include <stdio.h>
#include <string.h>
#include <pthread.h>

char buff[100];
pthread_rwlock_t rwlock;

void* th_writer(void *p)
{
    pthread_rwlock_wrlock(&rwlock);
    strcpy(buff, "hello, world!\n");
    printf("func[%s]: %s", __FUNCTION__, buff);
    sleep(1);
    pthread_rwlock_unlock(&rwlock);
    pthread_exit(0);
}

void* th_reader1(void *p)
{
    pthread_rwlock_rdlock(&rwlock);
    printf("func[%s]: %s", __FUNCTION__, buff);
    sleep(2);
    pthread_rwlock_unlock(&rwlock);
    pthread_exit(0);
}

void* th_reader2(void *p)
{
    pthread_rwlock_rdlock(&rwlock);
    printf("func[%s]: %s", __FUNCTION__, buff);
    sleep(1);
    pthread_rwlock_unlock(&rwlock);
    pthread_exit(0);
}

int main()
{
    pthread_t tid1, tid2, tid3;
    void *ret1, *ret2, *ret3;
    /* 下面调用需要处理返回值，这里未处理 */
    pthread_rwlock_init(&rwlock, NULL);
    pthread_create(&tid1, NULL, th_writer, NULL);
    pthread_create(&tid2, NULL, th_reader1, NULL);
    pthread_create(&tid3, NULL, th_reader2, NULL);
    pthread_join(tid1, &ret1);
    pthread_join(tid2, &ret2);
    pthread_join(tid3, &ret3);
    pthread_rwlock_destroy(&rwlock);
    return 0;
}