Concurrency

线程的产生

多线程并发高级接口std::async()和类std::future<>

1，async()使得可调用对象以线程形式运行在后台，但不保证立即执行

2，类future<>可以等待线程结束，访问线程的返回值或异常，使用它的get()方法可以强制启动线程并获取返回值或异常

头文件,支持多线程，支持时间

std::future  result1(std::async(func1));//启动线程now,later,never

result1.get();//程序阻塞直到线程结束

// force func1() to start asynchronously now or throw std::system_error，error code  resource_unavailable_try_again

std::future result1= std::async(std::launch::async, func1);//强制启动线程

std::future result1= std::async(std::launch::deferred, func1);//线程休眠直到调用get()，lazy evaluation

默认的launch协议是async和deferred

使用了launch policy，将不需要使用get()，程序会等待线程结束，但也可以调用get()主动促使线程执行、结束。

wait()函数等待线程结束（可能促使启动线程）

wait_for(chrono::second(10));//至多等待10秒，不强制启动线程

wait_until(chrono::system_clock::now() + chrono::minutes(1));//等待直到某个时间点，不强制启动线程

它们的返回值为

1，future_status::deferred ，如果async()延迟了操作（线程未启动）且没有调用wait()或get()

2，future_status::timeout，如果操作已经异步启动了但还没终止

3，future_status::ready，操作已经结束了

通过测试返回值可以了解线程的状态

使用this_thread::yield()或休眠this_thread::sleep_for()一段时间，用在长时间的循环中执行其他线程

使用async时传递给可调用对象的参数应该为值传递或常引用传递，lambda不使用mutable；除此之外需要明确传的参数的生命周期。

可调用对象是函数或函数指针时可以传递额外的参数

async(func, var_to_func);

async(mem_func, ref_or_pointer_of_object, var_to_mem_func);

std::shared_future类类似std::future类，但是可以多次调用get()获得同样的返回值或同样的异常

shared_future f = async(func1);

或者 auto f = async(func1).share();

多线程低级接口std::thread类

void doSomething();

std::thread t(doSomething); // start doSomething() in the background

...

t.join(); // wait for t to finish (block until doSomething() ends)

没有launch协议，创建时就会启动线程，失败则抛出std::system_error，错误码resource_unavailable_try_again；无法获取线程运行的结果，只可以获取线程id，出现异常会立即终止程序，调用join()等待线程结束或调用detach()是线程静默运行，主程序结束时所有线程会中断运行

多线程低级接口std::promise类，类似于future类，用来存储线程相关值或者线程的异常（不可同时存储）

使用set_value()存储值，set_exception(current_exception())存储当前异常

promise p;//比如在线程内部存储值或异常

future f(p.get_future());//获取promise存储的值

f.get();//阻塞直到promise的值准备好，取出promise的值，若使用set_value_at_thread_exit和set_exception_at_thread_exit则当线程结束时可取出promise的值

多线程低级接口std::packaged_task类（用于不立即执行的场景或创建线程池）

double compute (int x, int y);

std::packaged_task task(compute); // create a task

std::future f = task.get_future(); // get its future

...

task(7,5); // start the task (typically in a separate thread)

...

double res = f.get(); // wait for its end and process result/exception

类furure<>代表了操作的结果，可由async、packaged_task、promise产生，并且只可以使用一次，多次使用会抛出异常

promise可以暂保存线程的返回值或异常，使用get_future()获取保存的值，但只可以调用一次，多次调用抛出future_error(std::future_errc::future_already_retrieved)，若没有保存则抛出future_error(std::future_errc::no_state)；promise的线程操作时安全的。

packaged_task同时拥有操作和它的结果（返回值或异常），调用get_future()的行为类似于promise，但调用任务多次时抛出future_error(std::future_errc::promise_already_satisfied)；调用reset()会抛弃保存的值，当值没有准备好时存储std::future_error(std::future_errc::broken_promise)

thread类在其生命周期内必须调用join()或detach()，否则使程序终止

unsigned int std::thread::hardware_concurrency ();//静态成员函数

返回可能的线程数（不一定正确），返回0表示无法统计

this_thread命名空间

全局函数（包括主线程）

线程同步和并发问题

data race

Unsynchronized data access

Half-written data

Reordered statements

以上问题的解决依赖于

Atomicity

Order

可使用

future、promise；mutexes、locks；condition var；atomic 数据类型；fences

mutex在没有释放一个lock时去lock同一个mutex，抛出system_error(resource_deadlock_would_occur)；但使用recursive_mutex则不会出现问题，可以被同一个线程lock多次

mutex使用lock和unlock成员函数获取锁和释放锁

尝试获取lock

try_lock

尝试一段时间获取lock，timed_mutex和recursive_timed_mutex类以及try_lock_for(),try_lock_until()函数

timed_lock

一个线程同时获得多个锁（但不知道顺序），std::lock()函数阻塞直到获取了特定的锁或者发生异常（此时会失去获得的锁），可避免死锁

std::lock

尝试获取多个锁，无法避免死锁，但是锁的顺序是和传的参数顺序一样

std::try_lock

类unique_lock类似于lock_guard类，但是未必含有锁，且可以自主控制lock和unlock行为，在对象销毁时会主动释放锁（若有锁的话）

类似于unique_ptr，unique_lock可以释放或转移锁的拥有权给其他使用者。

mutex类簇

lock()可能抛出异常system_error(operation_not_permitted、resource_deadlock_would_occur、device_or_resource_busy)

lock_guard类

unique_lock类

只调用一次的操作

std::once_flag oc; // global flag

...

std::call_once(oc,func); 

条件变量，头文件，一个线程可以唤醒一个或多个其他等待中的线程

创建条件变量

#include

#include

mutex readyMutex;

condition_variable readyCondVar;

发送信号的线程行为

readyCondVar.notify_one(); // notify one of the waiting threads or

或者readyCondVar.notify_all(); // notify all the waiting threads

等待信号的线程的行为

unique_lock   l(readyMutex);

readyCondVar.wait(l);

有可能出现虚假唤醒，即线程没有达到唤醒的条件就被唤醒了，此时应该检查是否满足条件

condition_variable类和condition_variable_any类

创建条件变量失败抛出system_error（resource_unavailable_try_again）

condition_variable_any类没有native_handle()和notify_all_at_thread_exit()

所有等待同一个条件变量的线程必须使用同一个mutex；

wai_for或wait_until没有pred参数时返回std::cv_status::timeout或std::cv_status::no_timeout，取决于是否收到了条件变量的信号；有pred参数时返回pred的结果

原子操作

atomic  readyFlag(false);//定义原子对象

或者

atomic  readyFlag;

atomic_init(&readyFlag,false);

成员函数store()赋予一个新值，load()获取当前值，例如

readyFlag.store(true);//由于保证了操作的原子性，就不需要加锁了

triv表示原子数据的类型为bool或其他一般类型；int type表示原子数据的类型为整型；ptr type则为指针类型

CAS即compare and swap 操作：如果值被其他线程更新过，赋予新值并返回false

CAS近似实现

mo即内存顺序memory_order_seq_cst，memory_order_release，memory_order_acquire，memory_order_relaxed