数据保护

　　同许多线程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后，则是安全的。