Question

我见过很多种多线程和锁的接口。

这让我感到沮丧，

其中一些包括2个不同的类，如下面的示例，而

其他人只有一个类，而acquire（）可以实现等待函数。

我的问题是：为什么我们在面向对象编程中设计这样的锁？

如何操纵这些物体？

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

    // Acquire the lock.
   void
   acquire()
   { this->lock_->acquire(); }

    // Release the lock.
   void
   release()
   { this->lock_->release(); }

   private:
   // This class can not be copied.
   Lock(const Lock&);
   Lock& operator=(const Lock&);

   friend class Condvar;
   Lock_impl*
   get_impl() const
   { return this->lock_; }

   Lock_impl* lock_;
};

class Condvar
{
 public:
  Condvar(Lock& lock);
  ~Condvar();
  // Wait for the condition variable to be signalled.  This should
  // only be called when the lock is held.
  void
  wait()
  { this->condvar_->wait(this->lock_.get_impl()); }

  // Signal the condition variable--wake up at least one thread
  // waiting on the condition variable.  This should only be called
  // when the lock is held.
  void
  signal()
  { this->condvar_->signal(); }

  // Broadcast the condition variable--wake up all threads waiting on
  // the condition variable.  This should only be called when the lock
  // is held.
  void
  broadcast()
  { this->condvar_->broadcast(); }

  private:
  // This class can not be copied.
  Condvar(const Condvar&);
  Condvar& operator=(const Condvar&);

  Lock& lock_;
  Condvar_impl* condvar_;
};

Answer 1

锁的目的是防止两个不同的处理线程同时修改相同的内存位置。

当线程锁定代码区域，第二个线程进入相同的代码区域时，第二个线程将等待第一个线程在执行代码之前释放其锁定。

Answer 2

以上是锁和条件变量这是两个独特的概念：

锁只是一个原子锁开启或关闭。

条件变量（更难以正确使用）并且需要锁定才能正确实现但保持状态（基本上是计数）。

有关“条件变量”的信息，请参阅：
http://en.wikipedia.org/wiki/Monitor_(synchronization)

基本上条件变量是用于创建“监视器”（也称为监视区域）的低级基元。监视器是设计用于多个线程的代码区域（但通常是受控数量（在简单情况下为一个））但仍然是多线程安全的。

以下是使用“条件变量”的一个很好的例子 How to implement blocking read using POSIX threads

基本上允许2个线程进入Monitor区域。线程正在从向量中读取，而第二个线程正在从向量中进行操作。 'Monitor'控制2个线程之间的交互。虽然使用锁定可以达到同样的效果但是正确地执行它会非常/非常困难。

如何操纵这个界面？

2 个答案: