特性： 读写锁也叫共享——排他锁，因为有3种状态, 所以可以有更高的并行性。使用mutex，它的状态要么处于锁住和未锁状态，只有一个线程可以上锁。而读写锁有更多的状态：在读状态锁住，在写状态锁住，未锁住。只有一个线程可以获得写锁，多个线程可以同时获得读锁。 • 当读写锁是写加锁状态时, 在这个锁被解锁之前, 所有试图对这个锁加锁的线程都会被阻塞。 • 当读写锁在读加锁状态时, 所有试图以读模式对它进行加锁的线程都可以得到访问权, 但是如果线程希望以写模式对此锁进行加锁, 它必须阻塞知道所有的线程释放锁。 • 通常, 当读写锁处于读模式锁住状态时, 如果有另外线程试图以写模式加锁, 读写锁通常会阻塞随后的读模式锁请求, 这样可以避免读模式锁长期占用, 而等待的写模式锁请求长期阻塞。 适用性： 读写锁适合读比写频繁情形。读写锁和互斥量一样也需要在使用前初始化，在释放他们内存的时候销毁。 初始化和销毁：
C++代码 int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr); int pthread_rwlock_destroy(pthread_rwlock_t *restrict rwlock); int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr); int pthread_rwlock_destroy(pthread_rwlock_t *restrict rwlock);一个读写锁可以调用pthread_rwlock_init来初始化，我们可以传递NULL作为attr的参数，这样会使用读写锁的默认属性。我们可以调用pthread_rwlock_destroy来清理，销毁它所占的内存空间。 读和写：
C++代码 int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock); int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock); int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock); int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);实现上可能会对读写锁中读模式的锁锁住次数有一定的限制，所以我们需要检查返回值，以确定是否成功。而其他的两个函数会返回错误，但是只要我们的锁设计的恰当，我们可以不必做检查。 非阻塞的函数为：
C++代码 int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock); int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock); int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock); int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);当锁成功获取时，返回0，否则返回EBUSY。这两个函数可以避免死锁。 如果针对未初始化的读写锁调用进行读写操作，则结果是不确定的。 释放：
C++代码 int pthread_rwlock_unlock(pthread_rwlock_t *rwlock); int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);用来释放在 rwlock 引用的读写锁对象中持有的锁。 如果调用线程未持有读写锁 rwlock，或者针对未初始化的读写锁调用该函数，则结果是不确定的。 例子：
C++代码 #define _XOPEN_SOURCE 500 #include <pthread.h> #define PTHREAD_RWLOCK_INITIALIZER_READ_PREF { {0, 0}, 0, NULL, NULL, NULL, PTHREAD_RWLOCK_PREFER_READER_NP, PTHREAD_PROCESS_PRIVATE } static pthread_rwlock_t a = PTHREAD_RWLOCK_INITIALIZER; void *route_3 ( void *p) { sleep(2); printf("locking 3 = %d/n" , pthread_rwlock_rdlock(&a)); pause(); return NULL; } void *route_2 ( void *p) { sleep(1); printf("locking 2 = %d/n" , pthread_rwlock_wrlock(&a)); pause(); return NULL; } void *route_1 ( void *p) { printf("locking 1 = %d/n" , pthread_rwlock_rdlock(&a)); pause(); return NULL; } main() { pthread_t t1, t2, t3; pthread_create(&t1, NULL, route_1, NULL); pthread_create(&t2, NULL, route_2, NULL); pthread_create(&t3, NULL, route_3, NULL); pthread_join(t1, NULL); pthread_join(t2, NULL); pthread_join(t3, NULL); } #define _XOPEN_SOURCE 500 #include <pthread.h> #define PTHREAD_RWLOCK_INITIALIZER_READ_PREF { {0, 0}, 0, NULL, NULL, NULL, PTHREAD_RWLOCK_PREFER_READER_NP, PTHREAD_PROCESS_PRIVATE } static pthread_rwlock_t a = PTHREAD_RWLOCK_INITIALIZER; void *route_3 (void *p) { sleep(2); printf("locking 3 = %d/n", pthread_rwlock_rdlock(&a)); pause(); return NULL; } void *route_2 (void *p) { sleep(1); printf("locking 2 = %d/n", pthread_rwlock_wrlock(&a)); pause(); return NULL; } void *route_1 (void *p) { printf("locking 1 = %d/n", pthread_rwlock_rdlock(&a)); pause(); return NULL; } main() { pthread_t t1, t2, t3; pthread_create(&t1, NULL, route_1, NULL); pthread_create(&t2, NULL, route_2, NULL); pthread_create(&t3, NULL, route_3, NULL); pthread_join(t1, NULL); pthread_join(t2, NULL); pthread_join(t3, NULL); }C++代码 #include <errno.h> #include <pthread.h> static pthread_rwlock_t listlock; static int lockiniterror = 0; static pthread_once_t lockisinitialized = PTHREAD_ONCE_INIT; static void ilock( void ) { lockiniterror = pthread_rwlock_init(&listlock, NULL); } int initialize_r( void ) { /* must be called at least once before using list */ if (pthread_once(&lockisinitialized, ilock)) lockiniterror = EINVAL; return lockiniterror; } int accessdata_r( void ) { /* get a nonnegative key if successful */ int error; int errorkey = 0; int key; if (error = pthread_rwlock_wrlock(&listlock)) { /* no write lock, give up */ errno = error; return -1; } key = accessdata(); if (key == -1) { errorkey = errno; pthread_rwlock_unlock(&listlock); errno = errorkey; return -1; } if (error = pthread_rwlock_unlock(&listlock)) { errno = error; return -1; } return key; } int adddata_r(data_t data) { /* allocate a node on list to hold data */ int error; if (error = pthread_rwlock_wrlock(&listlock)) { /* no writer lock, give up */ errno = error; return -1; } if (adddata(data) == -1) { error = errno; pthread_rwlock_unlock(&listlock); errno = error; return -1; } if (error = pthread_rwlock_unlock(&listlock)) { errno = error; return -1; } return 0; } int getdata_r( int key, data_t *datap) { /* retrieve node by key */ int error; if (error = pthread_rwlock_rdlock(&listlock)) { /* no reader lock, give up */ errno = error; return -1; } if (getdata(key, datap) == -1) { error = errno; pthread_rwlock_unlock(&listlock); errno = error; return -1; } if (error = pthread_rwlock_unlock(&listlock)) { errno = error; return -1; } return 0; } int freekey_r( int key) { /* free the key */ int error; if (error = pthread_rwlock_wrlock(&listlock)) { errno = error; return -1; } if (freekey(key) == -1) { error = errno; pthread_rwlock_unlock(&listlock); errno = error; return -1; } if (error = pthread_rwlock_unlock(&listlock)) { errno = error; return -1; } return 0; } #include <errno.h> #include <pthread.h> static pthread_rwlock_t listlock; static int lockiniterror = 0; static pthread_once_t lockisinitialized = PTHREAD_ONCE_INIT; static void ilock(void) { lockiniterror = pthread_rwlock_init(&listlock, NULL); } int initialize_r(void) { /* must be called at least once before using list */ if (pthread_once(&lockisinitialized, ilock)) lockiniterror = EINVAL; return lockiniterror; } int accessdata_r(void) { /* get a nonnegative key if successful */ int error; int errorkey = 0; int key; if (error = pthread_rwlock_wrlock(&listlock)) { /* no write lock, give up */ errno = error; return -1; } key = accessdata(); if (key == -1) { errorkey = errno; pthread_rwlock_unlock(&listlock); errno = errorkey; return -1; } if (error = pthread_rwlock_unlock(&listlock)) { errno = error; return -1; } return key; } int adddata_r(data_t data) { /* allocate a node on list to hold data */ int error; if (error = pthread_rwlock_wrlock(&listlock)) { /* no writer lock, give up */ errno = error; return -1; } if (adddata(data) == -1) { error = errno; pthread_rwlock_unlock(&listlock); errno = error; return -1; } if (error = pthread_rwlock_unlock(&listlock)) { errno = error; return -1; } return 0; } int getdata_r(int key, data_t *datap) { /* retrieve node by key */ int error; if (error = pthread_rwlock_rdlock(&listlock)) { /* no reader lock, give up */ errno = error; return -1; } if (getdata(key, datap) == -1) { error = errno; pthread_rwlock_unlock(&listlock); errno = error; return -1; } if (error = pthread_rwlock_unlock(&listlock)) { errno = error; return -1; } return 0; } int freekey_r(int key) { /* free the key */ int error; if (error = pthread_rwlock_wrlock(&listlock)) { errno = error; return -1; } if (freekey(key) == -1) { error = errno; pthread_rwlock_unlock(&listlock); errno = error; return -1; } if (error = pthread_rwlock_unlock(&listlock)) { errno = error; return -1; } return 0; }
C++代码 #include <pthread.h> #include <sys/types.h> #include <sys/stat.h> //文件状态结构 #include <unistd.h> #include <sys/mman.h> //mmap头文件 #define BSIZE 10 typedef struct { char buf[BSIZE]; int occupied; int nextin; int nextout; pthread_mutex_t mutex; pthread_cond_t more; pthread_cond_t less; } buffer_t; char consumer(buffer_t *b) { char item; pthread_mutex_lock(&b->mutex); while (b->occupied <= 0) pthread_cond_wait(&b->more, &b->mutex); assert(b->occupied > 0); item = b->buf[b->nextout++]; b->nextout %= BSIZE; b->occupied--; /* now: either b->occupied > 0 and b->nextout is the index of the next occupied slot in the buffer, or b->occupied == 0 and b->nextout is the index of the next (empty) slot that will be filled by a producer (such as 使用条件变量 120 多线程编程指南• 2006年10月 示例4–13 生成方和使用者问题：使用者（续） b->nextout == b->nextin) */ pthread_cond_signal(&b->less); pthread_mutex_unlock(&b->mutex); return (item); } void producer(buffer_t *b, char item) { pthread_mutex_lock(&b->mutex); while (b->occupied >= BSIZE) pthread_cond_wait(&b->less, &b->mutex); assert(b->occupied < BSIZE); b->buf[b->nextin++] = item; b->nextin %= BSIZE; b->occupied++; /* now: either b->occupied < BSIZE and b->nextin is the index of the next empty slot in the buffer, or b->occupied == BSIZE and b->nextin is the index of the next (occupied) slot that will be emptied by a consumer (such as b->nextin == b->nextout) */ pthread_cond_signal(&b->more); pthread_mutex_unlock(&b->mutex); } void producer_driver(buffer_t *b) { int item; while (1) { item = getchar(); if (item == EOF) { producer(b, ‘/0’); break ; } else producer(b, (char )item); } return 0 } void consumer_driver(buffer_t *b) { char item; while (1) { if ((item = consumer(b)) == ’/0’) break ; putchar(item); } } int main() { int zfd; buffer_t *buffer; pthread_mutexattr_t mattr; pthread_condattr_t cvattr_less, cvattr_more; zfd = open("/dev/zero" , O_RDWR); buffer = (buffer_t *)mmap(NULL, sizeof (buffer_t),PROT_READ|PROT_WRITE, MAP_SHARED, zfd, 0); buffer->occupied = buffer->nextin = buffer->nextout = 0; pthread_mutex_attr_init(&mattr); pthread_mutexattr_setpshared(&mattr,PTHREAD_PROCESS_SHARED); pthread_mutex_init(&buffer->lock, &mattr); pthread_condattr_init(&cvattr_less); pthread_condattr_setpshared(&cvattr_less, PTHREAD_PROCESS_SHARED); pthread_cond_init(&buffer->less, &cvattr_less); pthread_condattr_init(&cvattr_more); pthread_condattr_setpshared(&cvattr_more,PTHREAD_PROCESS_SHARED); pthread_cond_init(&buffer->more, &cvattr_more); if (fork() == 0) consumer_driver(buffer); else producer_driver(buffer); }
