实现一个读写锁

读写锁:

    在编写多线程的时候,有一种情况是十分常见的。那就是,有些公共数据修改的机会比较少。相比较改写,它们读的机会反而高的多。通常而言,在读的过程中,往往伴随着查找的操作,中间耗时很长。给这种代码段加锁,会极大地降低我们程序的效率。那么有没有一种方法,可以专门处理这种多读少写的情况呢?有,那就是读写锁。

    读写锁实际是一种特殊的自旋锁,它把对共享资源的访问者划分成读者和写者,读者只对共享资源进行读访问,写者则需要对共享资源进行写操作。这种锁相对于自旋锁而言,能提高并发性,因为在多处理器系统中,它允许同时有多个读者来访问共享资源,最大可能的读者数为实际的逻辑CPU数。写者是排他性的,一个读写锁同时只能有一个写者或多个读者(与CPU数相关),但不能同时既有读者又有写者。

读写锁特点:

1)多个读者可以同时进行读

2)写者必须互斥(只允许一个写者写,也不能读者、写者同时进行)

3)写者优先于读者(一旦有写者,则后续读者必须等待,唤醒时优先考虑写者)

 读写锁在pthread中已经存在。

pthread_rwlock_init()
pthread_rwlock_rdlock()
pthread_rwlock_wrlock()
pthread_rwlock_unlock()

读写锁相关的操作函数:

实现一个读写锁_第1张图片

读写锁操纵:

wKioL1csUZCSp7Z_AAA8Iyc4p2o381.png

实现一个读写锁:(在vs上的写的)

一、使用互斥锁和条件变量实现读写锁.

#include
using namespace std;
#include
#include  
#include  


class readwrite_lock
{
public:
	readwrite_lock()
		: stat(0)
	{
	}

	void readLock()
	{
		mtx.lock();
		while (stat < 0)
			cond.wait(mtx);
		++stat;
		mtx.unlock();
	}

	void readUnlock()
	{
		mtx.lock();
		if (--stat == 0)
			cond.notify_one(); // 叫醒一个等待的写操作
		mtx.unlock();
	}

	void writeLock()
	{
		mtx.lock();
		while (stat != 0)
			cond.wait(mtx);
		stat = -1;
		mtx.unlock();
	}

	void writeUnlock()
	{
		mtx.lock();
		stat = 0;
		cond.notify_all(); // 叫醒所有等待的读和写操作
		mtx.unlock();
	}

private:
	unique_lock mtx;
	condition_variable cond;
	int stat; // == 0 无锁;> 0 已加读锁个数;< 0 已加写锁
};

 二、使用2个互斥锁实现读写锁:

class readwrite_lock
{
public:
    readwrite_lock()
        : read_cnt(0)
    {
    }
 
    void readLock()
    {
        read_mtx.lock();
        if (++read_cnt == 1)
            write_mtx.lock();
 
        read_mtx.unlock();
    }
 
    void readUnlock()
    {
        read_mtx.lock();
        if (--read_cnt == 0)
            write_mtx.unlock();
 
        read_mtx.unlock();
    }
 
    void writeLock()
    {
        write_mtx.lock();
    }
 
    void writeUnlock()
    {
        write_mtx.unlock();
    }
 
private:
    mutex read_mtx;
    mutex write_mtx;
    int read_cnt; // 已加读锁个数
};
 

三: 用mutex和conditon实现写优先的读写锁

 
class RWLock {
private:
    pthread_mutex_t mxt;
    pthread_cond_t cond;
    int rd_cnt;//等待读的数量
    int wr_cnt;//等待写的数量
 
public:
    RWLock() :rd_cnt(0), wr_cnt(0) {
        pthread_mutex_init(&mxt,NULL);
        pthread_cond_init(&cond,NULL);
    }
 
    void readLock() {
        pthread_mutex_lock(&mxt);
 
        ++rd_cnt;
        while(wr_cnt > 0)
            pthread_mutex_wait(&cond, &mxt);
        
        pthread_mutex_unlock(&mxt);
    }
 
    void readUnlock() {
        pthread_mutex_lock(&mxt);
        
        --rd_cnt;
        if (rd_cnt == 0 )
            pthread_cond_signal(&cond);
 
        pthread_mutex_unlock(&mxt);
    }
 
    void writeLock() {
        pthread_mutex_lock(&mxt);
 
        ++wr_cnt;
        while (wr_cnt + rd_cnt >=2)
            pthread_cond_wait(&cond, &mxt);
 
        pthread_mutex_unlock(&mxt);
    }
 
    void writerUnlock() {
        pthread_mutex_lock(&mxt);
 
        --wr_cnt;
        if(wr_cnt==0)
            pthread_cond_signal(&cond);
 
        pthread_mutex_unlock(&mxt);
    }
};
 

你可能感兴趣的:(http)