试图在C++中实现生产者/消费者问题。我有一个问题:我应该在这里使用nofify_all还是notify_one方法?此外,欢迎任何反馈。
template <class T>
class Stack
{
public:
Stack(size_t size) : size_(size)
{
arr_ = new T[size_];
init();
}
~Stack()
{
delete[] arr_;
}
void init()
{
top_ = -1;
}
int capacity()
{
return static_cast<int>(size_) - top_ - 1;
}
void set(T num)
{
std::unique_lock<std::mutex> locker(mu);
cond.wait(locker, [this](){ return top_ < static_cast<int>(size_) - 1; });
top_++;
arr_[top_] = num;
std::cout << "Setting num: " << num << " Capacity: " << this->capacity() << std::endl;
locker.unlock();
cond.notify_one();
}
Т get()
{
std::unique_lock<std::mutex> locker(mu);
T top_value;
cond.wait(locker, [this](){ return top_ != -1; });
top_value = arr_[top_];
top_--;
std::cout << "Getting num: " << top_value << " Capacity: " << this->capacity() << std::endl;
locker.unlock();
cond.notify_one();
return top_value;
}
private:
size_t size_;
T* arr_;
int top_;
std::mutex mu;
std::condition_variable cond;
};主要:
int main()
{
Stack<int> stack(10);
std::vector<std::thread> producers;
std::vector<std::thread> consumers;
for (int i = 0; i <= 20; i++)
{
consumers.push_back(std::thread([&](){
stack.get();
}));
}
for (int i = 1; i <= 20; i++)
{
producers.push_back(std::thread([&](){
stack.set(i);
}));
}
for (auto& th : producers)
{
th.join();
}
for (auto& th : consumers)
{
th.join();
}
return 0;
}发布于 2016-08-07 01:57:09
关于测试工具代码的几点评论:
for (int i = 0; i <= 20; i++)
// ...
for (int i = 1; i <= 20; i++)你有21个消费者,只有20个生产商。这意味着您的测试代码永远不会终止,对吗?
你可以通过使用C风格语言的“半开放范围”成语来避免这样的错误。用C、C++、Java、C#、JavaScript、Perl或其他语言编写的每个for-循环都应该如下所示:
for (int i = 0; i < N; ++i)请注意,它从0开始(包括)并上升到N (排它),因此它精确地迭代N时间。
consumers.push_back(std::thread([&](){
stack.get();
}));是一种冗长的写作方式
consumers.emplace_back([&](){ stack.get(); });我看到你在写
arr_ = new T[size_];-这是个红旗.更喜欢使用std::vector<T>或std::unique_ptr<T[]>而不是原始指针。原因是,在复制构造和/或移动构造时,这些代码将正常运行,而当前基于指针的代码需要特殊成员函数(构造函数和赋值操作符)中的一些额外代码才能正确工作。
查找零规则,并尝试在这里应用它。
由于您依赖析构函数来delete[]在构造函数中分配的数组,所以您应该=delete复制构造函数和复制赋值操作符;否则,您将允许客户端代码创建浅层副本,从而导致使用“后免”和“双免”错误。
但!当前代码实际上会导致隐式删除的复制构造函数,因为默认定义可能格式错误,因为无法复制构造std::condition_variable。因此,您很好,模块化一些非常详细的错误消息和危险,有人可能会出现并重构您的类,以删除不可复制的成员。
Stack不应该是可复制的吗?或者至少可以移动?现在,您的Stack既不能复制,也不能移动,因为它的std::condition_variable和std::mutex成员。
set和get (分别用于push和pop )的名称选择不当。
capacity的名称space_left也是错误的。capacity这个词在C++中已经有了意义:它的意思是“最大可能的大小”,就像在std::vector::capacity中一样。当您试图为一个事物找到一个名称时,选择最能代表事物本身的名称--通常这很容易,因为大多数事物已经建立了名称(例如stack、push、pop)。当您需要一个真正没有名称的事物的名称时,您只需要避免将它命名为已经存在于词典中的其他东西(例如capacity)。
capacity需要是一个private成员函数,否则它需要接受互斥mu,否则客户端代码可以在其他线程调用x->get()的同时调用x->capacity(),然后突然出现了争用状态。
但是,如果您只是在capacity的主体上执行互斥锁,您会发现set和get都是死锁的,因为它们都调用capacity,而互斥mu已经(仍然)被锁定。
std::cout << "Getting num: " << top_value << " Capacity: " << this->capacity() << std::endl;
locker.unlock();在互斥下调用如此昂贵的I/O例程无论如何都是一个坏习惯。您至少可以稍微改进代码,将其重新表述为
int cap = this->capacity();
locker.unlock();
std::cout << "Getting num: " << top_value << " Remaining capacity: " << cap << std::endl;考虑一下当T不是默认构造的时候会发生什么;考虑一下当T是默认的可构造的,但是它的默认构造函数相对昂贵的时候会发生什么。在这种情况下你想要发生什么?
考虑一下当T是只移动的时候会发生什么。在这种情况下你想要发生什么?
考虑一下当set中的以下行抛出时会发生什么情况:
top_++;
arr_[top_] = num; // T::operator= THROWS AN EXCEPTION下次您从堆栈中get时会发生什么?在这种情况下你想要发生什么?
但基本上,这似乎是相当好的代码(对诸如push和pop以及for -循环之类的东西模块化错误的名称)。
在我看来,您使用互斥变量和条件变量似乎很好。notify_one可能比notify_all更高效,但两者都可以。
https://codereview.stackexchange.com/questions/138002
复制相似问题