本文采用知识共享署名 4.0 国际许可协议进行许可，转载时请注明原文链接，图片在使用时请保留全部内容，可适当缩放并在引用处附上图片所在的文章链接。

• 资料
  • 参考资料
  • code
• 并发与并行
  • 多进程并发
  • 多线程并发
• C++中的并发与多线程
• thread
  • std::thread
  • std:🧵:join
  • std:🧵:joinable
  • std:🧵:detach
  • ~thread()分析
• Mutex
  • Mutex 系列类(四种)
  • Lock 类（两种）
  • 其他类型
  • mutex函数
  • std::recursive_mutex
  • std::time_mutex
  • std::recursive_timed_mutex
  • lock_guard / unique_lock
    • std::lock_guard
    • std::unique_lock
    • 注意
• 多线程下生产者消费者模型
  • 单生产者-单消费者模型
  • 单生产者-多消费者模型
  • 多生产者-单消费者模型
  • 多生产者-多消费者模型
• future
  • std::future

资料

参考资料

C++11并发之std::thread
基于C++11并发库的线程池与消息队列多线程框架——std::thread类
C++11 并发指南一(C++11 多线程初探)
[c++11]多线程编程(五)——unique_lock

code

CplusParallel

并发与并行

并发：同一时间段内可以交替处理多个操作
并行：同一时间段内同时处理多个操作
如果程序的结构设计为可以并发执行的，那么在支持并行的机器上，程序可以并行地执行。

多进程并发

　　多个进程独立地运行，它们之间通过进程间常规的通信渠道传递讯息（信号，套接字，文件，管道等），这种进程间通信不是设置复杂就是速度慢，这是因为为了避免一个进程去修改另一个进程，操作系统在进程间提供了一定的保护措施，当然，这也使得编写安全的并发代码更容易。运行多个进程也需要固定的开销：进程的启动时间，进程管理的资源消耗。

多线程并发

　　在当个进程中运行多个线程也可以并发。线程就像轻量级的进程，每个线程相互独立运行，但它们共享地址空间，所有线程访问到的大部分数据如指针、对象引用或其他数据可以在线程之间进行传递，它们都可以访问全局变量。进程之间通常共享内存，但这种共享通常难以建立且难以管理，缺少线程间数据的保护。因此，在多线程编程中，我们必须确保每个线程锁访问到的数据是一致的。

C++中的并发与多线程

C++11标准提供了一个新的线程库，内容包括了管理线程、保护共享数据、线程间的同步操作、低级原子操作等各种类。

1
2
3
4
5

<thread>  : 包含std::thread类以及std::this_thread命名空间。管理线程的函数和类在该头文件中有声明；
<atomic> :包含std::atomic和std::atomic_flag类，以及一套C风格的原子类型和与C兼容的原子操作的函数；
<mutex> ：包含了与互斥量相关的类以及其他类型的函数；
<future>: 包含两个Provider类（std::promise和std::package_task）和两个Future类（std::future和std::shared_future）以及相关的类型和函数；
<condition_variable> : 包含与条件变量相关的类，包括std::condition_variable和std::condition_variable_any

thread

std::thread

1
2
3
4
5

int n = 0;
std::thread t1; // t1 is not a thread
std::thread t2(f1, n + 1); // pass by value
std::thread t3(f2, std::ref(n)); // pass by reference
std::thread t4(std::move(t3)); // t4 is now running f2(). t3 is no longer a thread

std:🧵:join

join 是让当前主线程等待所有的子线程执行完，才能退出。

std:🧵:joinable

用于检测线程是否有效,true : 代表该线程是可执行线程

std:🧵:detach

线程 detach 脱离主线程的绑定，主线程挂了，子线程不报错，子线程执行完自动退出。
线程 detach以后，子线程会成为孤儿线程，线程之间将无法通信。

~thread()分析

1
2
3
4

~thread() _NOEXCEPT {	    // 析构函数
    if (joinable())         // 线程是可结合的(可执行线程)，析构异常（也就是说只能析构不可结合的线程）
        _XSTD terminate();  // terminate会调用abort()来终止程序
}

joinable() = false :

空线程
move后的线程，即move(t),则t是不可结合的
join后的线程
detach后的线程

Mutex

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

Mutex 系列类(四种)

1
2
3
4

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

Lock 类（两种）

1
2

std::lock_guard，与 Mutex RAII 相关，方便线程对互斥量上锁。
std::unique_lock，与 Mutex RAII 相关，方便线程对互斥量上锁，但提供了更好的上锁和解锁控制。

其他类型

1
2
3
4

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

mutex函数

构造函数

std::mutex不允许拷贝构造，也不允许 move 拷贝，最初产生的 mutex 对象是处于 unlocked 状态的。

std::try_lock

尝试锁住互斥量，如果互斥量被其他线程占有，则当前线程也不会被阻塞。线程调用该函数也会出现下面 3 种情况，(1). 如果当前互斥量没有被其他线程占有，则该线程锁住互斥量，直到该线程调用 unlock 释放互斥量。(2). 如果当前互斥量被其他线程锁住，则当前调用线程返回 false，而并不会被阻塞掉。(3). 如果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)。

std::lock

可以同时对多个互斥量上锁。线程调用该函数会发生下面 3 种情况：(1). 如果该互斥量当前没有被锁住，则调用线程将该互斥量锁住，直到调用 unlock之前，该线程一直拥有该锁。(2). 如果当前互斥量被其他线程锁住，则当前的调用线程被阻塞住。(3). 如果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)。

std::unlock

解锁，释放对互斥量的所有权。

std::call_once

如果多个线程需要同时调用某个函数，call_once 可以保证多个线程对该函数只调用一次。

std::recursive_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::recursive_timed_mutex

和 std:recursive_mutex 与 std::mutex 的关系一样，std::recursive_timed_mutex 的特性也可以从 std::timed_mutex 推导出来。

lock_guard / unique_lock

std::lock_guard

与 Mutex RAII 相关，方便线程对互斥量上锁。
其原理是：声明一个局部的lock_guard对象，在其构造函数中进行加锁，在其析构函数中进行解锁。最终的结果就是：在定义该局部对象的时候加锁（调用构造函数），出了该对象作用域的时候解锁（调用析构函数）。
使用方法:

1. 首先需要包含mutex头文件
2. 然后创建一个锁 std::mutex mutex
3. 在需要被加锁的作用域内 将mutex传入到创建的std::lock_guard局部对象中

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

#include <mutex>    /*std::mutex、 std::lock_guard*/

std::mutex mutex;

void func()
{
     //lock_guard 互斥锁 作用域内不可拷贝构造
     {
         std::lock_guard<std::mutex> lg(m_mutex);
         //函数内容
     }
}

std::unique_lock

与 Mutex RAII 相关，方便线程对互斥量上锁，但提供了更好的上锁和解锁控制。
互斥锁保证了线程间的同步，但是却将并行操作变成了串行操作，这对性能有很大的影响，所以我们要尽可能的减小锁定的区域，也就是使用细粒度。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

class LogFile {
    std::mutex _mu;
    ofstream f;
public:
    LogFile() {
        f.open("log.txt");
    }
    ~LogFile() {
        f.close();
    }
    void shared_print(string msg, int id) {
        {
            std::lock_guard<std::mutex> guard(_mu);
            //do something 1
        }
        //do something 2
        {
            std::lock_guard<std::mutex> guard(_mu);
            // do something 3
            f << msg << id << endl;
            cout << msg << id << endl;
        }
    }

};

上面的代码中，一个函数内部有两段代码需要进行保护，这个时候使用lock_guard就需要创建两个局部对象来管理同一个互斥锁（其实也可以只创建一个，但是锁的力度太大，效率不行），修改方法是使用unique_lock。它提供了lock()和unlock()接口，能记录现在处于上锁还是没上锁状态，在析构的时候，会根据当前状态来决定是否要进行解锁（lock_guard就一定会解锁）。上面的代码修改如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

class LogFile {
    std::mutex _mu;
    ofstream f;
public:
    LogFile() {
        f.open("log.txt");
    }
    ~LogFile() {
        f.close();
    }
    void shared_print(string msg, int id) {

        std::unique_lock<std::mutex> guard(_mu);
        //do something 1
        guard.unlock(); //临时解锁

        //do something 2

        guard.lock(); //继续上锁
        // do something 3
        f << msg << id << endl;
        cout << msg << id << endl;
        // 结束时析构guard会临时解锁
        // 这句话可要可不要，不写，析构的时候也会自动执行
        // guard.ulock();
    }

};

上面的代码可以看到，在无需加锁的操作时，可以先临时释放锁，然后需要继续保护的时候，可以继续上锁，这样就无需重复的实例化lock_guard对象，还能减少锁的区域。同样，可以使用std::defer_lock设置初始化的时候不进行默认的上锁操作：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

void shared_print(string msg, int id) {
    std::unique_lock<std::mutex> guard(_mu, std::defer_lock);
    //do something 1

    guard.lock();
    // do something protected
    guard.unlock(); //临时解锁

    //do something 2

    guard.lock(); //继续上锁
    // do something 3
    f << msg << id << endl;
    cout << msg << id << endl;
    // 结束时析构guard会临时解锁
}

这样使用起来就比lock_guard更加灵活！然后这也是有代价的，因为它内部需要维护锁的状态，所以效率要比lock_guard低一点，在lock_guard能解决问题的时候，就是用lock_guard，反之，使用unique_lock。

注意

unique_lock和lock_guard都不能复制，lock_guard不能移动，但是unique_lock可以。

1
2
3
4
5
6
7
8
9

// unique_lock 可以移动，不能复制
std::unique_lock<std::mutex> guard1(_mu);
std::unique_lock<std::mutex> guard2 = guard1;  // error
std::unique_lock<std::mutex> guard2 = std::move(guard1); // ok

// lock_guard 不能移动，不能复制
std::lock_guard<std::mutex> guard1(_mu);
std::lock_guard<std::mutex> guard2 = guard1;  // error
std::lock_guard<std::mutex> guard2 = std::move(guard1); // error

多线程下生产者消费者模型

单生产者-单消费者模型

单生产者-单消费者模型中只有一个生产者和一个消费者，生产者不停地往产品库中放入产品，消费者则从产品库中取走产品，产品库容积有限制，只能容纳一定数目的产品，如果生产者生产产品的速度过快，则需要等待消费者取走产品之后，产品库不为空才能继续往产品库中放置新的产品，相反，如果消费者取走产品的速度过快，则可能面临产品库中没有产品可使用的情况，此时需要等待生产者放入一个产品后，消费者才能继续工作。
code:SingleProducer-SingleConsumer

单生产者-多消费者模型

与单生产者和单消费者模型不同的是，单生产者-多消费者模型中可以允许多个消费者同时从产品库中取走产品。所以除了保护产品库在多个读写线程下互斥之外，还需要维护消费者取走产品的计数器。
code:SingleProducer-MultipleConsumer

多生产者-单消费者模型

与单生产者和单消费者模型不同的是，多生产者-单消费者模型中可以允许多个生产者同时向产品库中放入产品。所以除了保护产品库在多个读写线程下互斥之外，还需要维护生产者放入产品的计数器。
code:MultipleProducer-SingleConsumer

多生产者-多消费者模型

该模型可以说是前面两种模型的综合，程序需要维护两个计数器，分别是生产者已生产产品的数目和消费者已取走产品的数目。另外也需要保护产品库在多个生产者和多个消费者互斥地访问。
code:MultipleProducer-MultipleConsumer

future

thread对象，它是C++11中提供异步创建多线程的工具。但是我们想要从线程中返回异步任务结果，一般需要依靠全局变量；从安全角度看，有些不妥；为此C++11提供了std::future类模板，future对象提供访问异步操作结果的机制，很轻松解决从异步任务中返回结果。

唯一期望(unique futures，std::future<>) std::future的实例只能与一个指定事件相关联。
共享期望(shared futures)(std::shared_future<>) std::shared_future的实例就能关联多个事件。

future 头文件中包含了以下几个类和函数：

Providers 类：std::promise, std::package_task
Futures 类：std::future, shared_future.
Providers 函数：std::async()
其他类型：std::future_error, std::future_errc, std::future_status, std::launch.

std::future

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

//通过async来获取异步操作结果
std::future<int>  result = std::async([](){ 
    std::this_thread::sleep_for(std::chrono::milliseconds(500));
    return 8; 
});

std::cout << "the future result : " << result.get() << std::endl;
std::cout << "the future status : " << result.valid() << std::endl;
try
{
    result.wait();  //或者 result.get() ,会异常
  //因此std::future只能用于单线程中调用 ，多线程调用使用std::share_future();
}
catch (...)
{
    std::cout << "get error....\n ";
}