c++11多线程笔记

1 thread类
thread f;
线程等待join()
线程分离detach()

thread类不可拷贝复制

std::this_thread::yield();

 

2 bind 与lambda表达式

 

 

3 move
void some_function();
void some_other_function();
std::thread t1(some_function); // 1
std::thread t2=std::move(t1); // 2
t1=std::thread(some_other_function); // 3
std::thread t3; // 4
t3=std::move(t2); // 5
t1=std::move(t3); // 6 由于t1 已经与一个线程相关联， 赋值操作将使程序崩溃 。 必须显式地等待线程完成或者分离它

4 mutex
用法
std::mutex some_mutex;
some_mutex.lock()
some_mutex.unlock()

策略 tag type 描述
(默认) 无 请求锁，阻塞当前线程直到成功获得锁。
std::defer_lock std::defer_lock_t 不请求锁。
std::try_to_lock std::try_to_lock_t 尝试请求锁，但不阻塞线程，锁不可用时也会立即返回。
std::adopt_lock std::adopt_lock_t 假定当前线程已经获得互斥对象的所有权，所以不再请求锁。

策略 std::lock_guard std::unique_lock std::shared_lock
(默认) √ √ √(共享)
std::defer_lock × √ √
std::try_to_lock × √ √
std::adopt_lock √ √ √

//unique_lock 可防止死锁
std::mutex mt1, mt2;
// thread 1
{
std::unique_lock lck1(mt1, std::defer_lock);
std::unique_lock lck2(mt2, std::defer_lock);
std::lock(lck1, lck2);
// do something
}
// thread 2
{
std::unique_lock lck1(mt1, std::defer_lock);
std::unique_lock lck2(mt2, std::defer_lock);
std::lock(lck2, lck1);
// do something
}

配合std::condition_variable， 在wait时释放锁

 

//lock_guard 自动析构
std::lock_guard guard(some_mutex);

5 atomic
内存模型
memory_order_release,memory_order_relaxed,memory_order_consume,memory_order_acquire,memoyr_order_acq_rel,memory_order_seq_cst(默认)

std::atomic_flag f = ATOMIC_FLAG_INIT; // 不能拷贝构造

std::atomic b(true); // 可以使用一个非原子类型赋值， 但不能拷贝构造

6
std::thread::hardware_concurrency()
std::async()

7 mutable
const 成员函数不能修改 类的成员 ， 用mubable修饰之后可更改