Linux 下的线程读写锁

有一种写优先读写锁,有如下特点：
1）多个读者可以同时进行读
2）写者必须互斥（只允许一个写者写，也不能读者写者同时进行）
3）写者优先于读者（一旦有写者，则后续读者必须等待，唤醒时优先考虑写者）

在Solaris 中直接提供了读写锁, 但是在Linux 中只提供了线程的读写锁, 这里记录了一些读写锁的资料.

1.Solaris .vs. Linux Posix 库函数

Solaris 库（lib 线程）	Linux POSIX 库（libp 线程）	操作
sema_destroy()	sem_destroy()	销毁信号状态。
sema_init()	sem_init()	初始化信号。
sema_post()	sem_post()	增加信号。
sema_wait()	sem_wait()	阻止信号计数。
sema_trywait()	sem_trywait()	减少信号计数。
mutex_destroy()	pthread_mutex_destroy()	销毁或禁用与互斥对象相关的状态。
mutex_init()	pthread_mutex_init()	初始化互斥变量。
mutex_lock()	pthread_mutex_lock()	锁定互斥对象和块，直到互斥对象被释放。
mutex_unlock()	pthread_mutex_unlock()	释放互斥对象。
cond_broadcast()	pthread_cond_broadcast()	解除对等待条件变量的所有线程的阻塞。
cond_destroy()	pthread_cond_destroy()	销毁与条件变量相关的任何状态。
cond_init()	pthread_cond_init()	初始化条件变量。
cond_signal()	pthread_cond_signal()	解除等待条件变量的下一个线程的阻塞。
cond_wait()	pthread_cond_wait()	阻止条件变量，并在最后释放它。
rwlock_init()	pthread_rwlock_init()	初始化读／写锁。
rwlock_destroy()	pthread_rwlock_destroy()	锁定读／写锁。
rw_rdlock()	pthread_rwlock_rdlock()	读取读／写锁上的锁。
rw_wrlock()	pthread_rwlock_wrlock()	写读／写锁上的锁。
rw_unlock()	pthread_rwlock_unlock()	解除读／写锁。
rw_tryrdlock()	pthread_rwlock_tryrdlock()	读取非阻塞读／写锁上的锁。
rw_trywrlock()	pthread_rwlock_trywrlock()	写非阻塞读／写锁上的锁。

2.使用mutex 来实现

设置三个互斥信号量：
rwmutex        用于写者与其他读者/写者互斥的访问共享数据
rmutex        用于读者互斥的访问读者计数器readcount
nrmutex        用于写者等待已进入读者退出,所有读者退出前互斥写操作

var   rwmutex,rmutex,nrmutex:semaphore:=1,1,1；  
int   readcount=0;

cobegin
    reader begin
        P(rwmutex);
        P(rmutex);
        readcount++;
        if (readcount == 1) P(nrmutex);  //有读者进入,互斥写操作
        V(rmutex);
        V(rwmutex);  //及时释放读写互斥信号量,允许其它读、写进程申请资源读数据；
        
        P(rmutex);
        readcount--;
        if(readcount == 0) V(nrmutex);  //所有读者退出,允许写更新
        V(rmutex);
    End
    
    writer begin
        P(rwmutex);    //互斥后续其它读者、写者
        P(nrmutex);    //如有读者正在读,等待所有读者读完
        写更新；
        V(nrmutex);    //允许后续新的第一个读者进入后互斥写操作  
        V(rwmutex);    //允许后续新读者及其它写者
    End  
coend  

3. 利用pthread_cond_* & pthread_mutex_* 实现rw_lock

#include  < pthread.h >
#include  < cstdlib >
#include  < ctime >
#include  < iostream >
using   namespace  std;

class  RWLock {

private  :
    pthread_mutex_t cnt_mutex;
    pthread_cond_t rw_cond;
     int  rd_cnt, wr_cnt;

    RWLock( const  RWLock & );
    RWLock &   operator =  ( const  RWLock & );

public  :
    RWLock(): rd_cnt( 0 ),wr_cnt( 0 )
        {
            pthread_mutex_init( & cnt_mutex, NULL);
            pthread_cond_init( & rw_cond, NULL);
        }

     void  get_shared_lock()
        {
            pthread_mutex_lock( & cnt_mutex);
             while  (wr_cnt  > 0 )
                {
                    pthread_cond_wait( & rw_cond, & cnt_mutex);
                }
            rd_cnt ++ ;
            pthread_mutex_unlock( & cnt_mutex);
        }

     void  release_shared_lock()
        {
            pthread_mutex_lock( & cnt_mutex);
            rd_cnt -- ;
             if  ( 0   ==  rd_cnt)
                {
                    pthread_cond_signal( & rw_cond);
                }
            pthread_mutex_unlock( & cnt_mutex);
        }

     void  get_exclusive_lock()
        {
            pthread_mutex_lock( & cnt_mutex);
             while  (rd_cnt + wr_cnt > 0 )
                {
                    pthread_cond_wait( & rw_cond, & cnt_mutex);
                }
            wr_cnt ++ ;
            pthread_mutex_unlock( & cnt_mutex);
        }

     void  release_exclusive_lock()
        {
            pthread_mutex_lock( & cnt_mutex);
            wr_cnt -- ;
            pthread_cond_broadcast( & rw_cond);
            pthread_mutex_unlock( & cnt_mutex);
        }

     ~ RWLock()
        {
            pthread_mutex_destroy( & cnt_mutex);
            pthread_cond_destroy( & rw_cond);
        }
};

class  Test
{

private  :    
    RWLock  lock ;
    
     static   void *  shared_task_handler( void *  arg)
        {
            Test *  testptr  =  static_cast < Test *> (arg);

            testptr -> lock .get_shared_lock();
             // do the shared task here
            testptr -> lock .release_shared_lock();
        }


     static   void   *  exclusive_task_handler( void   *  arg)
        {
            Test *  testptr  =  static_cast < Test *> (arg);
            testptr -> lock .get_exclusive_lock();
             // do the exclusive task here
            testptr -> lock .release_exclusive_lock();
        }

public  :
    typedef  void *  ( * ThreadFunc) ( void * );

     void  start()
        {
            srand(time(NULL));

             const   int  THREADS_NO = rand() % 100 ;
            pthread_t *  threads  =   new  pthread_t[THREADS_NO];

             for ( int  i = 0 ; i < THREADS_NO; i ++ )
                {
                    ThreadFunc tmpfunc  =  rand() % 2 ?  shared_task_handler : exclusive_task_handler;
                     if  (pthread_create(threads + i,NULL,tmpfunc, this ))
                        {
                            cerr  <<   " pthread_create fails "   <<  endl;
                            exit( 1 );
                        }
                }

             for ( int  i = 0 ; i < THREADS_NO; i ++ )
                {
                    pthread_join(threads[i],NULL);
                }

            delete[] threads;
        }
};

int  main()
{
    Test tmptest;
    tmptest.start();
}

--------------------------
参考:
Solaris 執行緒與同步機制之實例
Posix线程编程指南