5

当我试图唤醒另一个线程时，我遇到了一个问题。一个简单的生产者/消费者的东西。

代码下方。第 85 行是我不明白为什么它不起作用的地方。生产者线程填满一个 std::queue 并调用 std::condition_variable.notify_one()，而消费者线程正在等待 NOT std::queue.empty()。

提前感谢您的帮助

#include <mutex>
#include <condition_variable>
#include <queue>
#include <string>
#include <iostream>
#include <thread>

// request
class request :
    public std::mutex,
      public std::condition_variable,
      public std::queue<std::string>
{
public:
  virtual ~request();
};

request::~request()
{
}

// producer
class producer
{
public:
  producer(request &);

  virtual ~producer();

  void operator()();

private:
  request & request_;
};

producer::producer(request & _request)
:
request_(_request)
{
}

producer::~producer()
{
}

void
producer::operator()()
{
  while (true) {
    std::lock_guard<std::mutex> lock(request_);
    std::cout << "producer\n";
    request_.push("something");
    std::this_thread::sleep_for(std::chrono::seconds(1));
    request_.notify_one();
  }
}

class consumer
{
public:
  consumer(request &);

  virtual ~consumer();

  void operator()();

private:
  request & request_;
};

consumer::consumer(request & _request)
:
request_(_request)
{
}

consumer::~consumer()
{
}

void
consumer::operator()()
{
  while (true) {
    std::unique_lock<std::mutex> lock(request_); // <-- the problem
    std::cout << "consumer\n";
    request_.wait (
      lock, [this] {return !request_.empty();}
    );
    request_.pop();
  }
}

int
main()
{
  // request
  request request_;

  // producer
  std::thread producer_{producer(request_)};

  // consumer
  std::thread first_consumer_{consumer(request_)};
  std::thread second_consumer_{consumer(request_)};

  // join
  producer_.join();
  first_consumer_.join();
  second_consumer_.join();
}
4

2 回答 2

12

修复了以下代码，并进行了以下更改：

  • 不要像那样从互斥体、condvar 和队列中派生出来，这太可怕了。
  • 在将项目添加到队列后尽快解锁互斥锁，关键部分应始终尽可能小。这允许消费者在生产者睡觉时醒来。
  • Flush cout（我曾经endl这样做）所以输出会立即打印出来，这样可以更容易地看到正在发生的事情。
  • "consumer" 醒来后打印，因为那是消费者正在消费的时候，否则你会得到误导性的输出，显示消费者什么时候睡觉，而不是什么时候有工作要做。

您的代码的主要问题是生产者从未给消费者运行的机会。它添加到队列中，睡了一秒钟（仍然持有互斥锁）然后通知条件变量（仍然持有互斥锁），然后很快释放互斥锁并再次获取它。可能你看到的是消费者线程收到通知，尝试获取互斥锁，发现它仍然被锁定（由生产者线程），所以又回到睡眠状态。生产者释放互斥锁的时间从来没有足够长的时间让另一个线程获取它。通过在生产者循环的开头添加 a 在锁定互斥锁之前，您可能已经能够获得更好的结果，但是依赖于的算法std::this_thread::yield()yield()因为正确性通常会被破坏（实际上它在我的测试中没有任何区别）；最好修复生产者循环，让消费者有机会醒来并运行。

这是工作代码：

#include <mutex>
#include <condition_variable>
#include <queue>
#include <string>
#include <iostream>
#include <thread>

// request
struct request
{
    std::mutex mx;
    std::condition_variable cv;
    std::queue<std::string> q;
};

// producer
class producer
{
public:
  producer(request & r) : request_(r) { }

  void operator()();

private:
  request & request_;
};

void
producer::operator()()
{
    while (true) {
        {
            std::lock_guard<std::mutex> lock(request_.mx);
            std::cout << "producer" << std::endl;
            request_.q.push("something");
        }
        std::this_thread::sleep_for(std::chrono::seconds(1));
        request_.cv.notify_one();
    }
}

class consumer
{
public:
  consumer(request & r) : request_(r) { }

  void operator()();

private:
  request & request_;
};

void
consumer::operator()()
{
  while (true) {
    std::unique_lock<std::mutex> lock(request_.mx);
    request_.cv.wait (
      lock, [this] {return !request_.q.empty();}
    );
    std::cout << "consumer" << std::endl;
    request_.q.pop();
  }
}

int
main()
{
  // request
  request request_;

  // producer
  std::thread producer_{producer(request_)};

  // consumer
  std::thread first_consumer_{consumer(request_)};
  std::thread second_consumer_{consumer(request_)};

  // join
  producer_.join();
  first_consumer_.join();
  second_consumer_.join();
}
于 2013-05-17T18:28:38.270 回答
0

您必须std::unique_lock在调用之前解锁您的，notify_one()否则您的 while 循环将尝试在同一个线程中锁定两次。这对生产者和消费者都有效。

但是，我同意那些说您根据要求进行的推导非常具有误导性的观点。你应该使用组合。如果你给我 10 分钟，我可能会想出一些有用的东西:)

于 2013-05-17T16:31:56.590 回答