Question

我有一个类，它使用互斥锁和两个条件变量来实现线程生产者/消费者系统以进行同步。当有项目要使用时，生产者向消费者线程发出信号，消费者在消费者消费项目时向生产者线程发出信号。线程继续生成和消耗，直到析构函数通过设置布尔变量请求它们退出。因为任何一个线程可能正在等待一个条件变量，我必须对quit变量进行第二次检查，这感觉错误和杂乱......

我已将问题简化为以下内容（使用g ++ 4.7处理GNU / Linux）示例：

// C++11and Boost required.
#include <cstdlib> // std::rand()
#include <cassert>

#include <boost/circular_buffer.hpp>

#include <atomic>
#include <chrono>
#include <condition_variable>
#include <iostream>
#include <mutex>
#include <thread>
#include <vector>

// Creates a single producer and single consumer thread.
class prosumer
{
    public:
        // Create the circular buffer and start the producer and consumer thread.
        prosumer()
            : quit_{ false }
            , buffer_{ circular_buffer_capacity }
            , producer_{ &prosumer::producer_func, this }
            , consumer_{ &prosumer::consumer_func, this }
        {}

        // Set the quit flag and wait for the threads to exit.
        ~prosumer()
        {
            quit_ = true;
            producer_.join();
            consumer_.join();
        }

    private:
        // Thread entry point for the producer.
        void producer_func()
        {
            // Value to add to the ringbuffer to simulate data.
            int counter = 0;

            while ( quit_ == false )
            {
                // Simulate the production of some data.
                std::vector< int > produced_items;
                const auto items_to_produce = std::rand() % circular_buffer_capacity;
                for ( int i = 0; i < items_to_produce; ++i )
                {
                    produced_items.push_back( ++counter );
                }

                // Get a lock on the circular buffer.
                std::unique_lock< std::mutex > lock( buffer_lock_ );

                // Wait for the buffer to be emptied or the quit flag to be set.
                buffer_is_empty_.wait( lock, [this]()
                        {
                            return buffer_.empty() == true || quit_ != false;
                        } );

                // Check if the thread was requested to quit.
                if ( quit_ != false )
                {
                    // Don't let the consumer deadlock.
                    buffer_has_data_.notify_one();
                    break;
                }

                // The buffer is locked by this thread. Put the data into it.
                buffer_.insert( std::end( buffer_ ), std::begin( produced_items ), std::end( produced_items ) );

                // Notify the consumer that the buffer has some data in it.
                buffer_has_data_.notify_one();
            }
            std::cout << "producer thread quit\n";
        }


        // Thread entry for the consumer.
        void consumer_func()
        {
            int counter_check = 0;

            while ( quit_ == false )
            {
                std::unique_lock< std::mutex > lock( buffer_lock_ );

                // Wait for the buffer to have some data before trying to read from it.
                buffer_has_data_.wait( lock, [this]()
                        {
                            return buffer_.empty() == false || quit_ != false;
                        } );

                // Check if the thread was requested to quit.
                if ( quit_ != false )
                {
                    // Don't let the producer deadlock.
                    buffer_is_empty_.notify_one();
                    break;
                }

                // The buffer is locked by this thread. Simulate consuming the data.
                for ( auto i : buffer_ ) assert( i == ++counter_check );
                buffer_.clear();

                // Notify the producer thread that the buffer is empty.
                buffer_is_empty_.notify_one();
            }
            std::cout << "consumer thread quit\n";
        }

        // How many items the circular buffer can hold. 
        static const int circular_buffer_capacity = 64;

        // Flag set in the destructor to signal the threads to stop.
        std::atomic_bool quit_;

        // Circular buffer to hold items and a mutex for synchronization.
        std::mutex buffer_lock_;
        boost::circular_buffer< int > buffer_;

        // Condition variables for the threads to signal each other.
        std::condition_variable buffer_has_data_;
        std::condition_variable buffer_is_empty_;

        std::thread producer_;
        std::thread consumer_;
};


int main( int argc, char **argv )
{
    (void)argc; (void) argv;

    prosumer test;

    // Let the prosumer work for a little while.
    std::this_thread::sleep_for( std::chrono::seconds( 3 ) );

    return EXIT_SUCCESS;
}

如果查看producer_func和consumer_func线程函数，您可以看到它们循环，直到由prosumer析构函数设置quit变量，但是在锁定循环缓冲区后它们也会再次检查quit变量。如果设置了quit变量，它们会相互发出信号以防止死锁。

我的另一个想法是从析构函数调用条件变量上的notify_one（），这会是一个更好的解决方案吗？

有更好的方法吗？

更新1：我忘了提到在这种情况下，当请求线程退出时，消费者不需要消耗循环缓冲区中的任何剩余数据，如果生产者产生更多的数据也没关系。只要它们都退出并且没有死锁，一切都会很好。

Answer 1

在我看来，在调用join之前，在析构函数中的两个条件变量上调用notify_one（或者更确切地说，如果你要将缓冲区扩展到多个生成器/使用者），由于以下几个原因：

首先，这与通常使用条件变量的方式相匹配：通过设置quit_，您可以更改生产者/消费者线程感兴趣的状态并等待，因此您应该通知它们状态更改。

此外，notify_one不应该是一项非常昂贵的操作。

另外，在更现实的应用中，情况可能是在两个元素的产生之间存在延迟;在这种情况下，你可能不想在你的析构函数中阻塞，直到消费者注意到下一个元素入队后它必须立即取消;在示例代码中，就我所见，这种情况并未发生。

Answer 2

在我看来，有两个功能可以分开：

消息传递和发送
制作和消费

将它们真正分开是有意义的：“工人”线程只会处理可能意味着“退出”或“do_work”的“消息”。

通过这种方式，您可以创建聚合实际功能的通用“工人”类。 produce和consume方法保持干净，worker类只关心如何继续工作。

如何正确退出可能在std :: condition_variable上等待的std :: thread？

2 个答案: