单写多读 线程锁怎么实现？

[nieoding]

我们一般的锁都是io单锁，例如A线程读，B线程写就锁了。这点逻辑上没问题
但是A线程读，B线程读逻辑上是完全没有必要锁的。
怎样实现单写多读锁？
听说boost下有read_write_lock专门解决这个问题的，后来又替换为shared_lock，搜了好久也没看见怎样使用shared_lock的范例。

[rollrock1987]

up

[xsc2001]

这个将可以通过全局变量和原子操作来完成。

[vocanicy]

在系统提供的锁机制之上自己实现一个逻辑锁

在系统互斥机制（临界区或者原子操作）保证互斥的基础上，可以用计数来实现

给个简单思路
设置一个读操作计数
计数<0时，表示在写；=0表示无操作；>0时，表示同时读操作数。

对读线程，如果计数<0，等待；如果计数>=0，则读操作之前将计数加一，进行读操作，结束时再减一
对写线程，如果计数>0，等待；只有计数=0时，将计数改为-1

[zoulie]

操作系统的一个经典例子 读者写者 问题

[jamesjinyongming]

你可以看《win32多线程程序设计》这本书，此书这种用法（read/Writer）的源代码我用过，很好用

[xuhb95083023]

无意中看到这篇老贴，回一下

// 运行后可以看到，write_process中输出到console的内容是有序的，而且在begin of write _process和end of write_process中不会有
// 其他信息，而read_process中输出到console的内容是杂乱无章的，这就模拟了single-write/multi-read

#include <iostream>

#include <boost/thread/thread.hpp>
#include <boost/thread/shared_mutex.hpp>

using namespace std;
using namespace boost;

boost::shared_mutex shr_mutex;

void write_process() {
    shr_mutex.lock();
    cout << "begin of write_process" << endl;
    cout << "end of write_process" << endl;
    shr_mutex.unlock();
}

void read_process() {
    shr_mutex.lock_shared();
    cout << "begin of read_process" << endl;
    cout << "end of read_process" << endl;
    shr_mutex.unlock_shared();
}

int main() {

    thread_group threads;
    for (int i = 0; i < 10; ++ i) {
        threads.create_thread(&write_process);
        threads.create_thread(&read_process);
    }

    threads.join_all();

    ::system("PAUSE");

    return 0;
}

[linxiwoaini]

[Quote=引用 3 楼 vocanicy 的回复:]

在系统提供的锁机制之上自己实现一个逻辑锁

在系统互斥机制（临界区或者原子操作）保证互斥的基础上，可以用计数来实现

给个简单思路
设置一个读操作计数
计数<0时，表示在写；=0表示无操作；>0时，表示同时读操作数。

对读线程，如果计数<0，等待；如果计数>=0，则读操作之前将计数加一，进行读操作，结束时再减一
对写线程，如果计数>0，等待；只有计数=0时，将计数改为-1
……
[/Quote]

说的不错不过有问题，如果一直有读在进行，写就一直在等待，没有机会得到锁了。

结构{
锁
写标志
读COUNT
}
读判断写标志真 ：等待
读判断写标志假 ：读加锁 读COUNT++ 解锁 读 读完 加锁 COUNT-- 解锁

写判断写标志真： 等待
写判断写标志假： 加锁 写标志真 解锁 等待 COUNT = 0 加锁 写 写标志假 解锁