相关疑难解决方法(0)

#include <boost/thread/condition.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/thread/thread.hpp>
#include <boost/circular_buffer.hpp>

// Thread safe circular buffer 
template <typename T>
class circ_buffer : private boost::noncopyable
{
public:
    typedef boost::mutex::scoped_lock lock;
    circ_buffer() {}
    circ_buffer(int n) {cb.set_capacity(n);}
    void send (T imdata) {
        lock lk(monitor);
        cb.push_back(imdata);
        buffer_not_empty.notify_one();
    }
    T receive() {
        lock lk(monitor);
        while (cb.empty())
            buffer_not_empty.wait(lk);
        T imdata = cb.front();
        cb.pop_front();
        return imdata;
    }
    void clear() {
        lock lk(monitor);
        cb.clear();
    }
    int size() {
        lock lk(monitor);
        return cb.size();
    }
    void set_capacity(int capacity) {
        lock …

Run Code Online (Sandbox Code Playgroud)

c++ multithreading boost opencv

Ale*_*xey

2012 09-29

32
推荐指数

2
解决办法

3万
查看次数

可以将std :: shared_timed_mutex上的共享锁升级为独占锁吗？

新的std :: shared_timed_mutex允许两种类型的锁:共享和独占.

如果有人持有共享锁,有没有办法以原子方式将它("升级它")交换为独占锁？换句话说,给定以下代码,我如何避免非原子性下降并重新锁定？

std::shared_timed_mutex m; //Guards a std::vector.
m.lock_shared();

//Read from vector. (Shared lock is sufficient.)
// ...

//Now we want to write to the vector. We need an exclusive lock.
m.unlock_shared();
                   //     <---- Problem here: non-atomic! 
m.lock(); 

//Write to vector.
// ...

m.unlock();

Run Code Online (Sandbox Code Playgroud)

理想情况下,m.unlock_shared(); m.lock();可以用类似m.upgrade_to_exclusive();(或类似的东西boost::.upgrade_to_unique_lock())替换.

在一个类似的问题,但对于Boost的shared_mutex Dave S提及

在不释放共享锁的情况下,无法从共享锁转换为唯一锁,或共享锁转换为可升级锁.

我不确定这是否适用于std :: shared_mutex,尽管我怀疑它确实如此.

基于std :: atomic/condition_variable或GCC的事务内存,我会对合理的解决方法感到满意.

编辑:霍华德的回答解决了我的问题.他的提议N3427包含了实现互斥升级的机制的很好的描述.我仍然欢迎基于std :: atomic/condition_variable或GCC事务内存的解决方法.

c++ multithreading c++11 c++14

use*_*401

2017 05-23

16
推荐指数

1
解决办法

3593
查看次数

提升shared_lock.阅读首选？

我正在查看用于读取器/写入器锁的boost库(版本1.45).当我对它进行测试时,似乎shared_ptr更喜欢我的读取器线程,即当我的编写器试图锁定它的操作时,它并没有阻止任何后续读取发生.

是否有可能在提升中改变这种行为？

using namespace std;
using namespace boost;

mutex outLock;
shared_mutex workerAccess;
bool shouldIWork = true;

class WorkerKiller
{
public:   

    void operator()()  
    {
        upgrade_lock<shared_mutex> lock(workerAccess); 
        upgrade_to_unique_lock<shared_mutex> uniqueLock(lock);

        cout << "Grabbed exclusive lock, killing system" << endl;
        sleep(2);
        shouldIWork = false;
        cout << "KILLING ALL WORK" << endl;  
    }  

private:  
};

class Worker
{  
public:   

    Worker()
    {  
    }  

    void operator()()  
    {
        shared_lock<shared_mutex> lock(workerAccess); 

        if (!shouldIWork) {
            outLock.lock();
            cout << "Workers are on strike.  This worker refuses to work" << endl;
            outLock.unlock(); …

Run Code Online (Sandbox Code Playgroud)

c++ boost

ano*_*aut

2012 08-28

15
推荐指数

1
解决办法

7343
查看次数

Boost中的多个读者,单个写入器锁

我正在尝试在多线程场景中实现以下代码:

Get shared access to mutex
Read data structure
If necessary:
   Get exclusive access to mutex
   Update data structure
   Release exclusive lock
Release shared lock

Run Code Online (Sandbox Code Playgroud)

Boost线程有一个shared_mutex专为多读者单作者模型设计的类.关于这个类,有几个stackoverflow问题.但是,我不确定它适合任何读者可能成为作家的情况.文件说明: