Question

我的程序是一个生产者线程从文本文件中读取文本行（有大约8000行文本）并将行加载到并发队列。

三个使用者线程读取队列中的每一行，每行写入一个单独的文件。

当我运行程序时，只有生产者线程和只有一个消费者线程完成。另外两个主题似乎挂了。

如何可靠地告诉所有消费者线程已到达文件末尾，以便他们返回但要确保队列完全是空的。

我的平台是Windows 7 64位

VC11。

编译为64位和32位的代码具有相同的行为。

这是代码。（它是独立的，可编辑的）

#include <queue>
#include<iostream>
#include<fstream>
#include <atomic>
#include <thread>
#include <condition_variable>
#include <mutex>
#include<string>
#include<memory>


template<typename Data>
class concurrent_queue
{
private:
    std::queue<Data> the_queue;
    mutable std::mutex the_mutex;
    std::condition_variable the_condition_variable;
public:
    void push(Data const& data){
        {
            std::lock_guard<std::mutex> lock(the_mutex);
            the_queue.push(data);
        }
        the_condition_variable.notify_one();
    }

    bool empty() const{
        std::unique_lock<std::mutex> lock(the_mutex);
        return the_queue.empty();
    }

    const size_t size() const{
        std::lock_guard<std::mutex> lock(the_mutex);
        return the_queue.size();
    }

    bool try_pop(Data& popped_value){
        std::unique_lock<std::mutex> lock(the_mutex);
        if(the_queue.empty()){
            return false;
        }
        popped_value=the_queue.front();
        the_queue.pop();
        return true;
    }

    void wait_and_pop(Data& popped_value){
        std::unique_lock<std::mutex> lock(the_mutex);
        while(the_queue.empty()){
            the_condition_variable.wait(lock);
        }
        popped_value=the_queue.front();
        the_queue.pop();
    }
};

std::atomic<bool> done(true);
typedef std::vector<std::string> segment;
concurrent_queue<segment> data;
const int one_block = 15;

void producer()
{
    done.store(false);
    std::ifstream inFile("c:/sample.txt");
    if(!inFile.is_open()){
        std::cout << "Can't read from file\n";
        return;
    }

    std::string line;
    segment seg;
    int cnt = 0;
    while(std::getline(inFile,line)){
        seg.push_back(line);
        ++cnt;
        if( cnt == one_block ){
            data.push( seg );
            seg.clear();
            cnt = 0;
        }
    }
    inFile.close();
    done.store(true);
    std::cout << "all done\n";
}

void consumer( std::string fname)
{
    std::ofstream outFile(fname.c_str());
    if(!outFile.is_open()){
        std::cout << "Can't write to file\n";
        return;
    }

    do{
        while(!data.empty()){
            segment seg;
            data.wait_and_pop( seg );
            for(size_t i = 0; i < seg.size(); ++i)
            {
                outFile << seg[i] << std::endl;
            }
            outFile.flush();
        }
    } while(!done.load());
    outFile.close();
    std::cout << fname << "  done.\n";
}

int main()
{
    std::thread th0(producer);
    std::thread th1(consumer, "Worker1.txt");
    std::thread th2(consumer, "Worker2.txt");
    std::thread th3(consumer, "Worker3.txt");

    th0.join();
    th1.join();
    th2.join();
    th3.join();

    return 0;
}

Answer 1

我用来终止在队列上等待的所有线程的方法是在队列上有一个标志，说明在检查pop()函数中是否有元素之前是否已完成测试。如果该标志指示程序应该停止，则任何调用pop()的线程如果队列中没有元素则抛出异常。更改标志后，更改的线程只会在相应的条件变量上调用notify_all()。

Answer 2

请查看以下代码：

while(!data.empty()){
    segment seg;
    data.wait_and_pop( seg );
    ...

考虑要读取最后一段数据的情况。和comsumers th1＆amp; th2正在等待读取数据。

消费者th1检查!data.empty()并发现有数据要读取。然后在th1调用data.wait_and_pop()之前，消费者th2检查!data.empty()并发现它为真。假设消费者th1消费最后一段。现在，由于没有要阅读的细分，th2会在the_queue.empty()的{{1}}上无限期等待。

尝试使用此代码代替上面的代码：

data.wait_and_pop()

应该让它发挥作用。

Answer 3

您可能希望向concurrent_queue添加布尔标志。读取文件后设置它（在互斥锁下）。读取文件和后，队列为空，从使用notify_all清空队列的使用者广播条件变量。

这将唤醒所有其他消费者，他们需要发现最终条件（标志设置和队列为空）并退出循环。为了避免竞争条件，这意味着他们需要在首先等待之前检查相同的组合条件。

现有标志的问题在于，从不等待condvar的线程永远不会检查它。 “完成”标志需要成为他们等待的状态的一部分。

[编辑：Dietmar对标志的含义略有不同可能导致代码更简单，但我没有将它们都写成比较。]

单一生产者 - 多个消费者：如何告诉消费者生产是否完整

3 个答案: