Thread-safe way to build mutex protection into a C++ class?

Question

I'm trying to implement a producer/consumer model multithreaded program in C++ for a project I'm working on. The basic idea is that the main thread creates a second thread to watch a serial port for new data, process the data and put the result in a buffer that is periodically polled by the main thread. I've never written multi-threaded programs before. I've been reading lots of tutorials, but they're all in C. I think I've got a handle on the basic concepts, but I'm trying to c++ify it. For the buffer, I want to create a data class with mutex protection built in. This is what I came up with. 1) Am I going about this the wrong way? Is there a smarter way to implement a protected data class? 2) What will happen in the following code if two threads try to call `ProtectedBuffer::add_back()` at the same time? ``` #include #include "pthread.h" template class ProtectedBuffer { std::deque buffer; pthread_mutex_t mutex; public: void add_back(T data) { pthread_mutex_lock(&…

Accepted Answer

Several things:

You need to initialize `mutex` with `pthread_mutex_init` in the constructor and free it with `pthread_mutex_destroy` in the destructor.

You must make your class non-copyable and non-assignable (or otherwise implement copy constructor and assignment operator correctly; see above).

It's worthwhile making a SBRM helper class for the lock:

```
class Lock
{
    pthread_mutex_t & m;
public:
    explicit Lock(pthread_mutex_t & _m) : m(_m) { pthread_mutex_lock(&m); }
    ~Lock() { pthread_mutex_unlock(&m); }
};
```

Now you can make a synchronized scope like `{ Lock lk(mutex); /* ... */ }`.

As for Question 2: Concurrent access is serialized by means of locking the mutex. One of the competing threads will sleep on the acquisition of the mutex lock.

Thread-safe way to build mutex protection into a C++ class?

Solution

Problem