Linux 下的线程读写锁

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();
}