C++11 并发指南

与 C++11 多线程相关的头文件

C++11 新标准中引入了四个头文件来支持多线程编程，他们分别是 ,,,<condition_variable>和。

：该头文主要声明了两个类, std::atomic 和 std::atomic_flag，另外还声明了一套 C 风格的原子类型和与 C 兼容的原子操作的函数。
：该头文件主要声明了 std::thread 类，另外 std::this_thread 命名空间也在该头文件中。
：该头文件主要声明了与互斥量(mutex)相关的类，包括 std::mutex 系列类，std::lock_guard, std::unique_lock, 以及其他的类型和函数。
<condition_variable>：该头文件主要声明了与条件变量相关的类，包括 std::condition_variable 和 std::condition_variable_any。
：该头文件主要声明了 std::promise, std::package_task 两个 Provider 类，以及 std::future 和 std::shared_future 两个 Future 类，另外还有一些与之相关的类型和函数，std::async() 函数就声明在此头文件中。

#include <stdio.h>
#include <iostream>
#include <thread>
#include <stdlib.h>
void thread_task(){
    std::cout<<"hello thread"<<std::endl;
}

int main(int argc,const char *argv[])
{
    std::thread t(thread_task);
    t.join();

    return EXIT_SUCCESS;
}

std::thread 在头文件中声明，因此使用 std::thread 时需要包含头文件。

std::thread 构造

(1). 默认构造函数，创建一个空的 thread 执行对象。

(2). 初始化构造函数，创建一个 thread对象，该 thread对象可被joinable，新产生的线程会调用 fn 函数，该函数的参数由 args 给出。

(3). 拷贝构造函数(被禁用)，意味着 thread 不可被拷贝构造。

(4). move 构造函数，move 构造函数，调用成功之后 x 不代表任何 thread 执行对象。

move赋值操作

(1). move 赋值操作，如果当前对象不可 joinable，需要传递一个右值引用(rhs)给 move 赋值操作；如果当前对象可被 joinable，则 terminate() 报错。

(2). 拷贝赋值操作被禁用，thread 对象不可被拷贝。

#include <stdio.h>
#include <stdlib.h>

#include <chrono>    // std::chrono::seconds
#include <iostream>  // std::cout
#include <thread>    // std::thread, std::this_thread::sleep_for

void thread_task(int n) {
    std::this_thread::sleep_for(std::chrono::seconds(n));
    std::cout << "hello thread "
        << std::this_thread::get_id()
        << " paused " << n << " seconds" << std::endl;
}

/*
 * ===  FUNCTION  =========================================================
 *         Name:  main
 *  Description:  program entry routine.
 * ========================================================================
 */
int main(int argc, const char *argv[])
{
    std::thread threads[5];
    std::cout << "Spawning 5 threads...\n";
    for (int i = 0; i < 5; i++) {
        threads[i] = std::thread(thread_task, i + 1);
    }
    std::cout << "Done spawning threads! Now wait for them to join\n";
    for (auto& t: threads) {
        t.join();
    }
    std::cout << "All threads joined.\n";

    return EXIT_SUCCESS;
}  /* ----------  end of function main  ---------- */

其他成员函数

gei_id 获取线程ID
joinable 检查线程是否可被join
detach Detach线程
swap Swap线程
native_handle 返回native_handle
hardware_concurrency[static] 检测硬件并发特性

std::mutex 详解

Mutex又称互斥量,c++11中与Mutex相关的类(包括锁类型)和函数都声明在头文件中,所以如果你需要使用 std::mutex，就必须包含头文件。

头文件介绍

Mutex系列类(四种)

std::mutex,最基本的Mutex类
std::recursive_mutex,递归Mutex类
std::time_mutex,定义Mutex类
std::recursive_timed_mutex,定时递归Mutex类

Lock类

std::lock_guaed,方便线程对互斥量上锁
std::unique_lock,方便线程对互斥量上锁,提供更好的上锁和解锁控制

其他类型

std::once_flag
std::adopt_lock_t
std::defer_lock_t
std::try_to_lock_t

函数

std::try_lock，尝试同时对多个互斥量上锁。
std::lock，可以同时对多个互斥量上锁。
std::call_once，如果多个线程需要同时调用某个函数

call_once 可以保证多个线程对该函数只调用一次。

std::mutex介绍

std::mutex 是C++11 中最基本的互斥量，std::mutex 对象提供了独占所有权的特性——即不支持递归地对 std::mutex 对象上锁，而 std::recursive_lock 则可以递归地对互斥量对象上锁。

std::mutex 的成员函数

构造函数 std::mutex不允许拷贝构造，也不允许 move 拷贝，最初产生的 mutex 对象是处于 unlocked 状态的。
lock()，调用线程将锁住该互斥量。线程调用该函数会发生下面 3 种情况：
(1). 如果该互斥量当前没有被锁住，则调用线程将该互斥量锁住，直到调用 unlock之前，该线程一直拥有该锁。
(2). 如果当前互斥量被其他线程锁住，则当前的调用线程被阻塞住。
(3). 如果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)。
unlock()，解锁，释放对互斥量的所有权。
try_lock()，尝试锁住互斥量，如果互斥量被其他线程占有，则当前线程也不会被阻塞。线程调用该函数也会出现下面 3 种情况，
(1). 如果当前互斥量没有被其他线程占有，则该线程锁住互斥量，直到该线程调用 unlock 释放互斥量。
(2). 如果当前互斥量被其他线程锁住，则当前调用线程返回 false，而并不会被阻塞掉。
(3). 如果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)。

std::recursize_mutex介绍

std::recursive_mutex 与 std::mutex 一样，也是一种可以被上锁的对象，但是和 std::mutex 不同的是，std::recursive_mutex 允许同一个线程对互斥量多次上锁（即递归上锁），来获得对互斥量对象的多层所有权，std::recursive_mutex 释放互斥量时需要调用与该锁层次深度相同次数的 unlock()，可理解为 lock() 次数和 unlock() 次数相同，除此之外，std::recursive_mutex 的特性和 std::mutex 大致相同。

std::time_mutex 介绍 std::time_mutex 比 std::mutex 多了两个成员函数，try_lock_for()，try_lock_until()。

try_lock_for 函数接受一个时间范围，表示在这一段时间范围之内线程如果没有获得锁则被阻塞住（与 std::mutex 的 try_lock() 不同，try_lock 如果被调用时没有获得锁则直接返回 false），如果在此期间其他线程释放了锁，则该线程可以获得对互斥量的锁，如果超时（即在指定时间内还是没有获得锁），则返回 false。

try_lock_until 函数则接受一个时间点作为参数，在指定时间点未到来之前线程如果没有获得锁则被阻塞住，如果在此期间其他线程释放了锁，则该线程可以获得对互斥量的锁，如果超时（即在指定时间内还是没有获得锁），则返回 false。

std::unique_lock 类 unique_lock 是通用互斥包装器，允许延迟锁定、锁定的有时限尝试、递归锁定、所有权转移和与条件变量一同使用。 unique_lock比lock_guard使用更加灵活，功能更加强大。使用unique_lock需要付出更多的时间、性能成本。

c++ 线程 join和detach

(1）当使用join()函数时，主调线程(main函数里有一个主调线程)阻塞，等待被调线程终止，然后主调线程回收被调线程资源，并继续运行；上面这段话的意思就是，使用join(),线程运行完,main函数才能结束。

（2）当使用detach()函数时，主调线程继续运行，被调线程驻留后台运行，主调线程无法再取得该被调线程的控制权。当主调线程结束时，由运行时库负责清理与被调线程相关的资源。上面这段话的意思就是，使用detach(),main函数不用等待线程结束才能结束。有时候线程还没运行完，main函数就已经结束了。

C++并发