Make accesible my stack from other threads c++ - c++

Question

I have a list of thread like this;
Kitchen::Kitchen(double multiplier, size_t cooks, size_t restock) :
_multiplier(multiplier), _ncooks(cooks), _restock(restock)
{
Cook *cook;
std::stack<APizza *> orders;
this->_ingredients = new Stock();
this->_ordersNow = 0;
this->_socket = initControlSocket();
for (size_t i = 0; i != _ncooks; i++) {
cook = new Cook(this, this->_multiplier);
this->_cooks.push_back(std::thread(&Cook::Run, cook));
}
dprintf(this->_socket, "%d\r\n", KITCHEN_OPENED);
}
i Want to make the std::stack< APizza *> orders; accessible and usable by all my threads in this->_cooks

Answer 1

Note that your threads may need a way to synchronize access to the stack, using a mutex for example, so you need to pass a reference to a mutex as well.
Have Cook::Run accept these arguments by reference:
void Run(std::mutex &, std::stack<APizza *> &);
Then pass a reference to them when you create the thread:
this->_cooks.push_back(std::thread(
&Cook::Run, cook,
std::ref(orders_mutex),
std::ref(orders)
));
As mentioned by others in the comment section, the stack will be destroyed when control leaves the Kitchen constructor. To prevent this, you could make the stack a data member of Kitchen.
Alternatively, since you need a mutex on this stack to synchronize concurrent access, you could create a wrapper class that holds the stack and the mutex, and guards access to the stack using the mutex.
template <typename T>
class threadsafe_stack {
public:
void push(T value) {
std::unique_lock<std::mutex> lock{mutex};
stack.push(std::move(value));
}
std::optional<T> pop() {
std::unique_lock<std::mutex> lock{mutex};
if (!stack.empty()) {
T val{std::move(stack.top())};
stack.pop();
return val;
}
return {};
}
private:
std::stack<T> stack;
std::mutex mutex;
};