Question

我正在尝试实现生产者 - 消费者模式。我完成了我的作业，但仍然无法确定。实施如下：

boost::mutex m_mutex;
boost::container::deque<T> m_buffer;
boost::condition_variable fifo_loaded;

T pop(void)
{
    boost::mutex::scoped_lock lock(m_mutex);

    while (m_buffer.empty())
    {  
        fifo_loaded.wait(lock); // As i understand, it releases the mutex, 
                                   and whenever it is notified, 
                                   gets it back again   
    }       
    T tmp = m_buffer.front();       
    m_buffer.pop_front();       
    return tmp; 
}


void push(const T &newElem) 
{       
    boost::mutex::scoped_lock lock(m_mutex);        
    m_buffer.push_back(newElem);        
    lock.unlock();      
    fifo_loaded.notify_one();   
}

生产者 - 消费者对如下。可以，还是我在这里也需要同步？

void produce_thread()
{
    while(true)
    {
        double data = generate_data();  
        m_buffer.push(data);
    }   
}

void consume_thread()
{
    while (true)
    {
        double data = m_buffer.pop();
        process_data(data);
    }
}

void start_system()
{
    boost::thread* thread_a = new boost::thread(capture_thread);
    boost::thread* thread_b = new boost::thread(process_thread);
}

如何手动停止线程？用下面的bool管理它可以吗？

bool enabled;

void produce_thread()
{
    while(enabled)
    {
        // Do stuff
    }   
}

void consume_thread()
{
    while (enabled)
    {
        // Do stuff
    }
}

Answer 1

您的示例实际上并未使用您编写的线程安全推送和弹出函数，它直接调用deque的push和pop函数。如果它确实使用了那些，那么它将是线程安全的，而且producer_thread / consumer_thread将不需要额外的同步

话虽如此，yohjp是正确的。你不能只有一个像“启用”这样的无保护的布尔值。 C ++ 11规范将数据速率定义为一个线程能够写入值而另一个线程能够读取或写入值的任何时间。这个定义与C ++ 11之前的编译器所使用的定义相匹配（它只是使其正式化）。

启用或者需要是一个原子布尔值，例如boost :: atomic，或者你需要一个额外的互斥锁来保护'enabled'，除非你持有互斥锁，否则你将无法读取或写入启用的规则。

提升条件变量用法

1 个答案: