线程通知工作不为我的消费

Question

我有一个制片人试图/消费者

生产者

#pragma once 
#ifndef PRODUCER_H 
#define PRODUCER_H 

#include <thread> 
#include "Mailbox.h" 

class Producer 
{ 
private: 
    std::thread producer; 
    Mailbox& mailbox; 
public: 
    Producer(Mailbox& newmailbox); 
    ~Producer(); 
    void start(); 
    void run(); 
}; 

Producer::Producer(Mailbox& newMailbox) : mailbox(newMailbox) {} 

Producer::~Producer() {} 

void Producer::start() 
{ 
    producer = std::thread(&Producer::run, this); 
} 

void Producer::run() 
{ 
    mailbox.inc(); 
} 

#endif 

消费者

#pragma once 
#ifndef CONSUMER_H 
#define CONSUMER_H 

#include "Mailbox.h" 
#include <thread> 
#include <iostream> 

class Consumer 
{ 
private: 
    Mailbox& mailbox; 
    std::thread consumer; 
public: 
    Consumer(Mailbox& newMailbox); 
    ~Consumer(); 
    void start(); 
    void run(); 
}; 

Consumer::Consumer(Mailbox& newMailbox) : mailbox(newMailbox) {} 


Consumer::~Consumer() {} 

void Consumer::start() 
{ 
    consumer = std::thread(&Consumer::run, this); 
} 

void Consumer::run() 
{ 
    mailbox.read(); 
} 

#endif 

邮箱

#pragma once 
#ifndef MAILBOX_H 
#define MAILBOX_H 

#include <mutex> 
#include <iostream> 

class Mailbox 
{ 
private: 
    int& mailbox; 
    int init_val; 
    std::mutex mmutex; 
    std::condition_variable condition; 
public: 
    Mailbox(); 
    ~Mailbox(); 
    void inc(); 
    void read(); 
}; 

Mailbox::Mailbox() : mailbox(init_val), init_val(0) {} 

Mailbox::~Mailbox() 
{ 

} 

void Mailbox::inc() 
{ 
    int count = 0; 
    while (count < 10) 
    { 

     std::unique_lock<std::mutex> lock(mmutex); 
     std::cout << "Producer increment\n"; 
     mailbox += 1; 
     lock.unlock(); 

     count += 1; 
    } 

} 

void Mailbox::read() 
{ 
    int count = 0; 
    while (count < 10) 
    { 

     std::unique_lock<std::mutex> lock(mmutex); 

     condition.wait(lock, [this](){return get_cflag(); }); 

     condition.notify_one(); 

     count += 1; 

    } 

} 

#endif 

主要

int main() 
{ 

    Mailbox* mailbox = new Mailbox(); 
    Consumer* consumer = new Consumer(*mailbox); 
    Producer* producer = new Producer(*mailbox); 

    consumer->start(); 
    producer->start(); 

    return 0; 
} 

互斥锁尽管异步的作品，因为我有过当std::thread将开始，所以我决定实现除使用std::unique_lock到std::mutex半同步方法无法控制的。

问题是，消费者等待并且生产者在未提示的情况下飞行，至少这是调试器告诉我的情况，以及最后一个生产者迭代结果是否中止（），因此出现问题。

Answer 1

我不是C++的人，但是如果这些条件变量按照我认为他们的方式工作，只有在信号到达时才会收到通知而您正在等待。如果信号到达之前您开始等待，您将无限期阻止。

当您获取'Mailbox :: read`中的锁定后，您应该检查项目是否可用，并且只有在条件变量上等待，如果不是之一。如果有，继续前进，把它：

int Mailbox::read() 
{ 
    std::unique_lock<std::mutex> lock(m); 
    while (mailbox <= 0) 
     condition.wait(lock); 
    return mailbox--; 
} 

Answer 2

基于戴维·施瓦茨的评论，从迈克·斯特罗贝尔，以及额外的研究见解，我改变了生产者和消费者功能

生产者

void Mailbox::inc() 
{ 
    int count = 0; 
    while (count < 10) 
    { 

     std::unique_lock<std::mutex> lock(mmutex); 
     std::cout << "Producer increment\n"; 
     mailbox += 1; 
     lock.unlock(); 
     set_cflag(true); // signal to the consumer data is ready 
     condition.notify_one(); 

     { 
      std::unique_lock<std::mutex> lock(mmutex); 
      condition.wait(lock, [this]() {return get_pflag(); }); 
     } 

     set_pflag(false); 

     count += 1; 
    } 

} 

消费者

void Mailbox::read() 
{ 
    int count = 0; 
    while (count < 10) 
    { 

     std::unique_lock<std::mutex> lock(mmutex); 

     condition.wait(lock, [this](){return get_cflag(); }); 

     std::cout << "Consumer: " << mailbox << "\n"; 
     lock.unlock(); 

     set_pflag(true); 
     condition.notify_one(); 

     count += 1; 

     set_cflag(false); 

    } 

} 

邮箱

class Mailbox 
{ 
private: 
    int& mailbox; 
    int cflag, pflag; 
    int init_val; 
    std::mutex mmutex; 
    std::condition_variable condition; 
public: 
    Mailbox(); 
    ~Mailbox(); 
    int get_cflag() { return cflag; } 
    void set_cflag(int newFlag) { cflag = newFlag; } 
    int get_pflag() { return pflag; } 
    void set_pflag(int newFlag) { pflag = newFlag; } 
    void inc(); 
    void read(); 
}; 

Mailbox::Mailbox() : mailbox(init_val), init_val(0), cflag(0), pflag(0) {} 

Mailbox::~Mailbox() 
{ 

} 

在执行时的输出是作为所期望我

int main() 
{ 

    Mailbox* mailbox = new Mailbox(); 
    Consumer* consumer = new Consumer(*mailbox); 
    Producer* producer = new Producer(*mailbox); 

    consumer->start(); 
    producer->start(); 

    fgetc(stdin); 

    return 0; 
} 

生产者增量

消费者：1

生产者增量

消费者：2

生产者增量

消费者：3

生产者增量

消费者：4

生产者增量

消费者：5

生产者增量

消费者：6

生产者增量

消费者：7

生产者增量

消费者：8

生产者增量

消费者：9

生产者增量

消费：10