C++0x概览：多线程（2）

C++0x概览：多线程（2）2010-07-22 vckbase yqever数据保护

同许多线程API一样，C++0x用互斥来保护共享数据。有四种互斥类型：

Non-recursive （std::mutex）

Recursive （std::recursive_mutex）

允许锁超时的non-recursive （std::timed_mutex）

允许锁超时的recursive （std::recursive_timed_mutex）

如果你试图在一个线程上锁（lock）一个non-recursive mutex两次而当中没有unlock它的话，会产生未知结果。递归recur6sive mutex只是增加锁的计数，因此必须确保你unlock和lock的次数相同，其他线程才可能锁这个mutex。

通常我们用模板类std::unique_lock<>和std::lock_guard<>来lock和unlock一个mutex。这些类在构造函数中lock一个mutex，在析构函数中unlock它。因此，如果你用的是局部变量，你的mutex会在退出作用域时自动被unlock。

std::mutex m;
  my_class data;
  void foo（）
  {
    std::lock_guard<std::mutex> lk（m）;
    process（data）;
}  // mutex unlocked here

std::lock_guard只能像上面这样使用。而std::unique_lock允许延迟lock、设置超时，以及在对象销毁之前unlock。如果你选择std::timed_mutex来设置锁超时的话，那需要使用std::unique_lock:

std::timed_mutex m;
  my_class data;
  void foo（）
  {
    std::unique_lock<std::timed_mutex>
      lk（m,std::chrono::milliseconds（3））; // wait up to 3ms
    if（lk） // if we got the lock, access the data
      process（data）;
}  // mutex unlocked here

由于这些lock类是模板，因此他们可以用于所有标准的mutex类型，以及提供了lock（）和unlock（）函数的扩展类型。

避免死锁

有时候，我们需要锁多个mutex。如果控制不力，可能导致死锁（deadlock）：两个线程都试图锁相同的mutex，每个线程都锁住一个mutex，而等待另外一个线程释放其他的mutex。C++0x考虑到了这个问题，你可以使用std::lock函数来一次锁住多个mutex，而不必冒着死锁的危险来一个一个地锁：

struct X
  {
    std::mutex m;
    int a;
    std::string b;
  };
  void foo（X& a,X& b）
  {
    std::unique_lock<std::mutex> lock_a（a.m,std::defer_lock）;
    std::unique_lock<std::mutex> lock_b（b.m,std::defer_lock）;
    std::lock（lock_a,lock_b）;
    // do something with the internals of a and b
  }

在上面的例子中，如果你不使用std::lock的话，将很可能导致死锁（如一个线程执行foo（x,y）, 另一个执行foo（y,x））。加上std::lock后，则是安全的。