// Mutex.h
 
#ifndef MUTEX_H_
#define MUTEX_H_
 
#include <pthread.h>
 
#include "noncopyable.h"
    
/**
 * 原始互斥锁的封装
 */
class MutexLock : private noncopyable
{
public:
    MutexLock();
    ~MutexLock();
 
    /// 加锁函数（仅允许 MutexLockGuard 类调用）
    void lock();
 
    /// 解锁函数（仅允许 MutexLockGuard 类调用）
    void unlock();
 
    /// 返回原始互斥锁类型的指针（仅允许 Condition 类调用）
    pthread_mutex_t *getPthreadMutex();
 
private:
    pthread_mutex_t mutex_;
};
 
/**
 * MutexLock 互斥锁的加/解锁类
 */
class MutexLockGuard : private noncopyable
{
public:
    /// 构造函数自动加锁
    explicit MutexLockGuard(MutexLock &mutex) : mutex_(mutex)
    {
        mutex_.lock();
    }
 
    /// 脱离作用域的时候自动解锁
    ~MutexLockGuard()
    {
        mutex_.unlock();
    }
 
private:
    MutexLock &mutex_;
};
 
/**
 * 下面的宏防止出现诸如 MutexLockGuard(mutex) 的定义
 * 正规做法是 MutexLockGuard lock(mutex)
 */
#define MutexLockGuard(x) static_assert(false, "missing mutex guarg var name!")
 
#endif // MUTEX_H_
 

// MutexLock.cpp
#include "MutexLock.h"
 
MutexLock::MutexLock()
{
    pthread_mutexattr_t attr;
    
    pthread_mutexattr_init(&attr);
    /// 初始化互斥锁类型为 PTHREAD_MUTEX_NORMAL
    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL);
    pthread_mutex_init(&mutex_, &attr);
    pthread_mutexattr_destroy(&attr);
}
 
MutexLock::~MutexLock()
{
    pthread_mutex_destroy(&mutex_);
}
 
void MutexLock::lock()
{
    pthread_mutex_lock(&mutex_);
}
 
void MutexLock::unlock()
{
    pthread_mutex_unlock(&mutex_);
}
 
pthread_mutex_t *MutexLock::getPthreadMutex()
{
    return &mutex_;
}
 

• 条件变量（condition variable）用于一个或者多个线程等待某个布尔表达式为真，即等待别的线程“唤醒”它，条件变量的学名叫管程（monitor）。对于wait端：

  • 条件变量必须与mutex一起使用，该布尔表达式的读写需受此mutex保护。
  • 在mutex已经上锁的时候才能调用wait()。
  • 把判断布尔条件和wait()放到while循环里（避免虚假唤醒（suprious wakeup））。
  • 对于signal/broadcast端
  • 不一定要再mutex已经上锁的情况下调用signal（理论上）。
  • 在signal之前一定要修改布尔表达式。修改布尔表达式的时候需用mutex保护。
  • 注意区分signal和broadcast。

• Linux下condition封装的一个实例：
  

   // Condition.h
   
  #ifndef CONDITION_H_
  #define CONDITION_H_
   
  #include <pthread.h>
   
  #include "noncopyable.h"
  #include "MutexLock.h"
   
  /**
   * 条件变量的封装类
   */
  class Condition : private noncopyable
  {
  public:
      /// 构造函数
      explicit Condition(MutexLock &mutex) : mutex_(mutex)
      {
          pthread_cond_init(&pcond_, NULL);
      }
   
      /// 析构函数
      ~Condition()
      {
          pthread_cond_destroy(&pcond_);
      }
   
      /// 等待该条件变量
      void wait()
      {
          pthread_cond_wait(&pcond_, mutex_.getPthreadMutex);
      }
   
      /// 通知一个等待该条件变量的线程
      void notify()
      {
          pthread_cond_signal(&pcond_);
      }
   
      /// 通知所有等待该条件变量的线程
      void notifyAll()
      {
          pthread_cond_broadcast(&pcond_);
      }
   
  private:
      MutexLock &mutex_;
      pthread_cond_t pcond_;
  };
   
  #endif // CONDITION_H_
   

• 真正影响性能的不是锁，而是锁争用（lock contention）。

• 必须用单线程的场合：

  • 程序有可能会fork(2)；
  • 限制程序的CPU使用率。

• 多线程的适用场景是：提高响应速度，让IO和“计算”相互重叠，降低latency。虽然多线程不能提高绝对性能，但能提高平均响应性能。