10

我正在寻找一种在 C++ 中将pthread rwlock结构与条件例程一起使用的方法。

我有两个问题：

第一：这怎么可能，如果我们不能，为什么？

第二：为什么当前的 POSIX pthread 没有实现这种行为？

为了理解我的目的，我解释了我的用途：我有一个生产者-消费者模型来处理一个共享数组。当数组为空时，消费者将 cond_wait，但在读取某些元素时会 rdlock。当从数组中添加（+信号）或删除元素时，生产者会出错。

使用 rdlock 代替 mutex_lock 的好处是提高性能：使用 mutex_lock 时，多个读取器会阻塞，而使用 rdlock 多个读取器不会阻塞。

4

6 回答 6

7

我假设“条件”是指“条件变量”。它们是不同的东西。

不，在等待条件变量时不能使用 rwlock。我无法回答“为什么”，但这就是 POSIX 决定这样做的方式。也许只是为了让事情变得简单。

但是，您仍然可以通过仅使用互斥锁和 2 个条件变量而不使用 POSIX rwlock 来创建自己的 rwlock 类来获得所需的行为：

getReadLock():
     lock(mutex)
     while(array.empty())
         wait(readersCondVar, mutex)
     readers++;
     unlock(mutex)       

releaseReadLock():
     lock(mutex)
     if (--readers == 0)
           broadcast(writerCondVar, mutex) // or signal, if only 1 producer
     unlock(mutex)

readerThread:
     forever() {
         getReadLock()
         read()
         releaseReadLock()
      }

getWriteLock():
     lock(mutex)
     while(readers) {
         wait(writerCondVar, mutex)
     }

releaseWriteLock():
     broadcast(readersCondVar, mutex)
     unlock(mutex)

writerThread():
      forever() {
         getWriteLock()
         write()
         releaseWriteLock()
      }

简单，做你想做的事。

于 2010-04-23T16:31:37.070 回答
2

我有和你一样的要求。

这是我的解决方案：

包装 pthread_rwlock_t

class rwlock
{
public:
    rwlock()
    {
        pthread_rwlock_init(&_lock, nullptr);
    }

    ~rwlock()
    {
        pthread_rwlock_destroy(&_lock);
    }

    void read_lock()
    {
        pthread_rwlock_rdlock(&_lock);
    }

    void write_lock()
    {
        pthread_rwlock_wrlock(&_lock);
    }

    bool try_read_lock()
    {
        return pthread_rwlock_tryrdlock(&_lock) == 0;
    }

    bool try_write_lock()
    {
        return pthread_rwlock_trywrlock(&_lock) == 0;
    }

    void lock()
    {
        read_lock();
    }

    void try_lock()
    {
        try_read_lock();
    }

    void unlock()
    {
        pthread_rwlock_unlock(&_lock);
    }

private:
    pthread_rwlock_t _lock;
};

用法

rwlock lock;

std::condition_variable_any cond;

bool ready = false;

制片人

lock.write_lock();
...
if (!ready) {
    ready = true;
    cond.notify_all();
}
lock.unlock();

消费者

std::unique_lock<rwlock> lock_(lock);
while (!ready) {
    cond.wait(lock_, []{ return ready; });
}
...
ready = false;
于 2013-09-11T03:45:53.343 回答
1

C++0x 正在获得多线程支持，该支持包括一个名为 condition_variable_any 的新类型：

class condition_variable_any
{
public:
    condition_variable_any();
    ~condition_variable_any();

    condition_variable_any(const condition_variable_any&) = delete;
    condition_variable_any& operator=(const condition_variable_any&) = delete;

    void notify_one();
    void notify_all();

    template <class Lock>
        void wait(Lock& lock);
    template <class Lock, class Predicate>
        void wait(Lock& lock, Predicate pred);

    template <class Lock, class Clock, class Duration>
        cv_status
        wait_until(Lock& lock,
                   const chrono::time_point<Clock, Duration>& abs_time);

    template <class Lock, class Clock, class Duration, class Predicate>
        bool
        wait_until(Lock& lock,
                   const chrono::time_point<Clock, Duration>& abs_time,
                   Predicate pred);

    template <class Lock, class Rep, class Period>
        cv_status
        wait_for(Lock& lock,
                 const chrono::duration<Rep, Period>& rel_time);

    template <class Lock, class Rep, class Period, class Predicate>
        bool
        wait_for(Lock& lock,
                 const chrono::duration<Rep, Period>& rel_time,
                 Predicate pred);
};

这里有一个关于如何实现 condition_variable_any 的解释：

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2406.html#gen_cond_var

但在此链接中，它被命名为 gen_cond_var。condition_variable_any 的神奇之处在于它会等待任何具有 lock() 和 unlock() 成员的东西。一旦你有了condition_variable_any，那么你只需要一个rwlock。上面的链接还介绍了 shared_mutex 和 shared_lock 并显示了执行您想要的示例代码：

std::tr2::shared_mutex mut;
std::gen_cond_var cv;

void wait_in_shared_ownership_mode()
{
    std::tr2::shared_lock<std::tr2::shared_mutex> shared_lk(mut);
    // mut is now shared-locked
    // ...
    while (not_ready_to_proceed())
        cv.wait(shared_lk);  // shared-lock released while waiting
    // mut is now shared-locked
    // ...
}   // mut is now unlocked

void wait_in_unique_ownership_mode()
{
    std::unique_lock<std::tr2::shared_mutex> lk(mut);
    // mut is now unique-locked
    // ...
    while (not_ready_to_proceed())
        cv.wait(lk);  // unique-lock released while waiting
    // mut is now unique-locked
    // ...
}   // mut is now unlocked

上述文件有些过时了。这里有 shared_mutex / shared_lock 的更新实现和描述：

http://howardhinnant.github.io/shared_mutex http://howardhinnant.github.io/shared_mutex.cpp

所有这些都是在 POSIX pthreads 之上实现的。我希望将共享锁定的内容写入 C++ 技术报告 (tr2)，但当然不能保证这一点。

于 2011-03-02T16:01:18.580 回答
0

对于您想要的，您只需要拥有 1 组 rwlock 和 1 组 mutex/cond 变量、伪代码（尽管您需要 posix cond 变量上的常用循环）

consumer() {

  get_readlock();
  if(array_empty()) {
    release_readlock();
    grab_mutex();
    wait_on_condition();
    release_mutex();
    get_readlock();
  }
  process_elements();
  release_readlock();
}

producer()
{
  get_writelock();
  get_mutex();
  insert_elements();
  signal_condition();
  release_mutex();
  release_writelock();
}

我猜条件变量只适用于互斥锁，因为等待或发出条件信号需要互斥。

于 2010-04-23T16:28:27.227 回答
0

在互斥锁和条件变量之上实现了几个RWLock。选择任何一个并添加一些 condvars 以满足您的自定义需求。

于 2012-09-11T08:18:57.887 回答
0

grab_mutex要解决世界末日信号的问题，必须在前后再次检查条件wait_on_condition：

consumer() {

  get_readlock();
  if(array_empty()) {
    release_readlock();
    grab_mutex();
    if(array_empty()) {
       wait_on_condition();
    }
    release_mutex();
    get_readlock();
  }
  process_elements();
  release_readlock();
}
于 2011-03-02T10:13:51.627 回答