0

我正在尝试实现生产者-消费者模式。我做了功课，但仍然不能确定。实现如下：

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
    }
}
4

1 回答 1

0

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

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

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

于 2013-09-02T06:16:54.827 回答