c++實現讀寫共享鎖

一、使用互斥鎖和條件變量實現讀寫鎖：

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:
    mutex mtx;
    condition_variable cond;
    int stat; // == 0 無鎖；> 0 已加讀鎖個數；< 0 已加寫鎖
};

二、使用2個互斥鎖實現讀寫鎖：

class ReadWriteLock
{
    ReadWriteLock() :m_readCount(0){}
public:
    void ReadLock()
    {
        std::lock_guard<std::mutex> lockGuard(m_readMtx);
        if (m_readCount == 0)
        {
            m_writeMtx.lock();
        }
        m_readCount++;
    }
    void ReadUnLock()
    {
        std::lock_guard<std::mutex> lockGuard(m_readMtx);
        m_readCount--;
        if (m_readCount == 0)
        {
            m_writeMtx.unlock();
        }
    }
    void WriteLock()
    {
        m_writeMtx.lock();
    }
    void WriteUnLock()
    {
        m_writeMtx.unlock();
    }
private:
    ReadWriteLock& operator=(const ReadWriteLock&) = delete;
    ReadWriteLock(const ReadWriteLock&) = delete;
private:
    std::mutex m_readMtx;
    std::mutex m_writeMtx;
    int m_readCount;
};

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