Question

我正在尝试用C ++实现一个生产者/消费者模型多线程程序，用于我正在研究的项目。基本思想是主线程创建第二个线程来监视新数据的串行端口，处理数据并将结果放入由主线程周期性轮询的缓冲区中。我以前从未编写过多线程程序。我一直在阅读很多教程，但是他们都在C中。我想我已经掌握了基本概念，但我正在尝试c ++ ify it。对于缓冲区，我想创建一个内置互斥保护的数据类。这就是我提出的。

1）我是否采取了错误的方式？有没有更智能的方法来实现受保护的数据类？

2）如果两个线程试图同时调用ProtectedBuffer::add_back()，以下代码会发生什么？

#include <deque>
#include "pthread.h"

template <class T>
class ProtectedBuffer {
  std::deque<T> buffer;
  pthread_mutex_t mutex;
public:
  void add_back(T data) {
    pthread_mutex_lock(&mutex);
    buffer.push_back(data);
    pthread_mutex_unlock(&mutex);
  }
  void get_front(T &data) {
    pthread_mutex_lock(&mutex);
    data = buffer.front();
    buffer.pop_front();
    pthread_mutex_unlock(&mutex);
  }
};

编辑：感谢所有伟大的建议。我试过在下面实现它们。我还添加了一些错误检查，所以如果一个线程以某种方式设法尝试锁定相同的互斥锁两次，它将优雅地失败。我想。

#include "pthread.h"
#include <deque>


class Lock {
    pthread_mutex_t &m;
    bool locked;
    int error;
public:
    explicit Lock(pthread_mutex_t & _m) : m(_m) {
        error = pthread_mutex_lock(&m);
        if (error == 0) {
            locked = true;
        } else {
            locked = false;
        }
    }
    ~Lock() {
        if (locked)
            pthread_mutex_unlock(&m);
    }
    bool is_locked() {
        return locked;
    }
};

class TryToLock {
    pthread_mutex_t &m;
    bool locked;
    int error;
public:
    explicit TryToLock(pthread_mutex_t & _m) : m(_m) {
        error = pthread_mutex_trylock(&m);
        if (error == 0) {
            locked = true;
        } else {
            locked = false;
        }
    }
    ~TryToLock() {
        if (locked)
            pthread_mutex_unlock(&m);
    }
    bool is_locked() {
        return locked;
    }
};

template <class T>
class ProtectedBuffer{
    pthread_mutex_t mutex;
    pthread_mutexattr_t mattr;
    std::deque<T> buffer;
    bool failbit;

    ProtectedBuffer(const ProtectedBuffer& x);
    ProtectedBuffer& operator= (const ProtectedBuffer& x);
public:
    ProtectedBuffer() {
        pthread_mutexattr_init(&mattr);
        pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_ERRORCHECK);
        pthread_mutex_init(&mutex, &mattr);
        failbit = false;
    }
    ~ProtectedBuffer() {
        pthread_mutex_destroy(&mutex);
        pthread_mutexattr_destroy(&mattr);
    }
    void add_back(T &data) {
        Lock lck(mutex);
        if (!lck.locked()) {
            failbit = true;
            return;
        }
        buffer.push_back(data);
        failbit = false;
    }
    void get_front(T &data) {
        Lock lck(mutex);
        if (!lck.locked()) {
            failbit = true;
            return;
        }
        if (buffer.empty()) {
            failbit = true;
            return;
        }
        data = buffer.front();
        buffer.pop_front();
        failbit = false;
    }
    void try_get_front(T &data) {
        TryToLock lck(mutex);
        if (!lck.locked()) {
            failbit = true;
            return;
        }
        if (buffer.empty()) {
            failbit = true;
            return;
        }
        data = buffer.front();
        buffer.pop_front();
        failbit = false;
    }
    void try_add_back(T &data) {
        TryToLock lck(mutex);
        if (!lck.locked()) {
            failbit = true;
            return;
        }
        buffer.push_back(data);
        failbit = false;
    }
};

Answer 1

有几件事：

您需要在构造函数中使用pthread_mutex_init初始化mutex，并在析构函数中使用pthread_mutex_destroy释放它。
您必须使您的类不可复制且不可分配（或以其他方式正确实现复制构造函数和赋值运算符;请参阅上文）。

为锁定制作一个SBRM助手类是值得的：

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

现在，您可以创建{ Lock lk(mutex); /* ... */ }等同步范围。

关于问题2：通过锁定互斥锁来序列化并发访问。其中一个竞争线程将在获取互斥锁时休眠。

Answer 2

我是以错误的方式来做这件事的吗？有没有更智能的方法来实现受保护的数据类？

对于你的实施，我认为你有一个良好的开端。既然你问过C ++ ifying，那么如果你有一个支持C ++ 11的编译器，你可以使用新的线程支持。

你提到你想让主线程轮询这个缓冲区，但我没有看到任何允许它这样做的机制。当缓冲区中没有任何内容时，get_front应该提供错误，或者get_buffer应阻止调用方，直到数据可用。

#include <deque>
#include <mutex>
#include <condition_variable>
#include <stdexcept>

template <class T>
class ProtectedBuffer {
  std::deque<T> buffer;
  std::mutex mtx;
  std::condition_variable empty_cnd;
  void get_front_i(T &data) {
    data = buffer.front();
    buffer.pop_front();
  }
public:
  void add_back(T data) {
    std::lock_guard<std::mutex> g(mtx);
    bool was_empty = buffer.empty();
    buffer.push_back(data);
    if (was_empty) empty_cnd.notify_one();
  }
  void get_front_check(T &data) {
    std::lock_guard<std::mutex> g(mtx);
    if (buffer.empty()) throw std::underflow_error("no data");
    get_front_i(data);
  }
  void get_front_block(T &data) {
    std::lock_guard<std::mutex> g(mtx);
    std::unique_lock<std::mutex> u(mtx);
    while (buffer.empty()) empty_cnd.wait(u);
    get_front_i(data);
    if (!buffer.empty()) empty_cnd.notify_one();
  }
};

如果要绑定添加到缓冲区的数据量，可以添加类似的full_cnd条件变量，以检查add_back调用等待的完整条件（如果是真正。然后，get_front_i方法可以在缓冲区不再满时发出信号。

如果两个线程试图同时调用ProtectedBuffer :: add_back（），下面的代码会发生什么？

由于add_back受到保护而不受相互排斥，如果两个线程同时调用它，则一个线程将被阻止调用push_back，直到完成另一个线程。

Answer 3

你有基础，但我会更进一步，将互斥锁本身包装在自己的RAII包装器中，例如：

#include <deque> 
#include "pthread.h" 

class ProtectedMutex
{
  pthread_mutex_t &mutex; 
public:
  ProtectedMutex(pthread_mutex_t &m)
    : mutex(m); 
  {
    pthread_mutex_lock(&mutex); 
  }
  ~ProtectedMutex()
  {
    pthread_mutex_unlock(&mutex); 
  }
};

template <class T> 
class ProtectedBuffer { 
  std::deque<T> buffer; 
  pthread_mutex_t mutex; 
public: 
  void add_back(T data) { 
    ProtectedMutex m(mutex); 
    buffer.push_back(data); 
  } 
  void get_front(T &data) { 
    ProtectedMutex m(mutex); 
    data = buffer.front(); 
    buffer.pop_front(); 
  } 
};

Answer 4

'将结果放入由主线程定期轮询的缓冲区中 - CPU浪费和延迟。

'我这样做错了吗？' - 是的我不知道你的系统对辅助线程有什么样的支持＆lt;＆gt; GUI线程通信，但总是有PostMessage（）API。

你需要一个Buffer类，当然还有一个用于串行rx数据的数据成员和一个用于执行协议/'过程数据'的方法。你不需要太多其他东西。在第二个线程中，创建一个缓冲类实例。加载它，处理数据和PostMessage / dispatch / BeginInvoke它指向你的GUI线程的指针。在SERIAL THREAD中非常接近的代码行中，在同一实例指针var中创建另一个实例，以便从串行端口下载数据。在GUI中显示/记录/之后，GUI线程应该删除（）它收到的*缓冲区。

没有延迟，没有CPU浪费，没有数据复制，串行线程和GUI线程没有机会在相同的缓冲区实例上工作，没有讨厌的，复杂的缓冲区共享代码，没有锁，没有麻烦。它会运作良好。

其他任何东西都会变得混乱。

编辑 - 忘了（2） - 不知道，。不会用驳船接触它..

将Mutex保护构建到C ++类的线程安全方法？

4 个答案: