c++ 多线程编程总结

前言：

并发：两个或者多个任务同时进行。
对于单核cpu而言，并发是假象，实际上在某一时刻只能执行一个任务，由操作系统调度。每秒进行多次的任务切换，即：上下文切换，需要时间开销–因为操作系统需要保存切换时的各种状态，执行的进度等等信息，切换回来之后需要恢复。
多余多核cpu，能够真正同时执行多个任务，即硬件上的并发。
进程：一个可执行程序运行起来后，产生了一个进程。
线程：理解为一条代码的执行道路，可以有多条。

线程并不是越多越好，每个线程都需要一个独立的堆栈空间（1M），且线程切换耗时。

并发的实现方式：
多进程并发：进程之间通信：同一个电脑，管道，文件，消息队列，共享内存等；不同电脑，socket通信技术。
多线程并发：一个进程中的所有线程共享内存，全局变量，指针，引用可以在线程之间传递。
比较：
和进程相比，线程有如下优点：
1.线程启动速度更快，更轻量级；
2.系统开销更小，执行速度更快。

1基础知识：

创建多个线程后，多个线程执行顺序是乱的，跟操作系统内部对运行调度有关。

创建线程：
头文件#include 中std::thread类。
std::thread th1(fun); 备注：只要传入了函数名或者可调用对象 作为该线程的参数，该线程就开始执行。
理解：
用函数名好说。
用类的话，需要重载(),thread myobj(对象名，参数);
调用成员函数： thread myobj(&类型：成员函数名，对象名，参数);
用lambda表达式,也好说。

注意到，在使用detach时，由于主线程和子线程分离。若主线程结束，thread的参数：临时对象不存在了，会影响子线程的运行。这里有一点，在thread执行时，会以默认浅拷贝的方式，复制一份临时对象。所以，对于值传递，在使用detach时没什么影响。但对于指针和引用时，会出现问题。
无论使用detach还是join，都会执行拷贝构造函数。

使用std::ref(); 例：thread myobj(myprint,std::ref(value))；才能在线程中传递引用。

用成员函数指针做线程函数：
thread myobj(&A::thread_work,a,value); 参数列表(&类型::成员函数，对象名，值)；

整个进程执行完毕的标志是：主线程是否执行完毕，主线程若执行完毕，子线程会被操作系统强行终止。

thread类中包括join() 和detach() 成员方法，是两种线程阻塞方法，区别在于是否等待子线程执行结束。
join翻译为等待好理解：

整个过程就相当于：你在处理某件事情（你是主线程），中途你让老王帮你办一个任务（与你同时执行）（创建线程1，该线程取名老王），又叫老李帮你办一件任务（创建线程2，该线程取名老李），现在你的一部分工作做完了，剩下的工作得用到他们的处理结果，那就调用"老王.join()“与"老李.join()”，至此你就需要等待（主线程阻塞），等他们把任务做完（子线程运行结束），你就可以继续你手头的工作了（主线程不再阻塞）。

关于join的理解，有两个重要的点：
参考文章：C++ std::thread join()的理解

谁调用了这个函数？调用了这个函数的线程对象，一定要等这个线程对象的方法（在构造时传入的方法）执行完毕后（或者理解为这个线程的活干完了！），这个join()函数才能得到返回。
在什么线程环境下调用了这个函数？上面说了必须要等线程方法执行完毕后才能返回，那必然是阻塞调用线程的，也就是说如果一个线程对象在一个线程环境调用了这个函数，那么这个线程环境就会被阻塞，直到这个线程对象在构造时传入的方法执行完毕后，才能继续往下走，另外如果线程对象在调用join()函数之前，就已经做完了自己的事情（在构造时传入的方法执行完毕），那么这个函数不会阻塞线程环境，线程环境正常执行。

关于detach：即主线程和子线程各自独立执行。

守护线程
对于线程的分类，可简答划分为：
1.主线程 （main函数）
2.子线程 （除了main）
对子线程，可简单划分为:
1.守护线程
2.用户线程

2互斥量（锁）的使用

锁的本质属性是为事物提供“访问保护。c++中把锁称为互斥量（mutex）

单位上有一台打印机（共享数据a），你要用打印机（线程1要操作数据a），同事老王也要用打印机(线程2也要操作数据a)，但是打印机同一时间只能给一个人用，此时，规定不管是谁，在用打印机之前都要向领导申请许可证（lock），用完后再向领导归还许可证(unlock)，许可证总共只有一个,没有许可证的人就等着在用打印机的同事用完后才能申请许可证(阻塞，线程1lock互斥量后其他线程就无法lock,只能等线程1unlock后，其他线程才能lock)。那么，打印机就是共享数据，访问打印机的这段代码就是临界区，这个必须互斥使用的许可证就是互斥量（锁）。

互斥量的使用是为了解决多个线程共享资源时造成的冲突问题。这里的互斥量保证了使用打印机这一过程不被打断。
对于任意一个线程，如果想访问共享资源，首先要进行"加锁"操作，1.若加锁成功，则进行对共享资源的操作，操作完后记得释放锁。2.如果“加锁”不成功，则线程阻塞，直到加锁成功。
即：在操作数据时，锁住-操作-解锁。其他想要操作该数据的线程，需要等待解锁-锁住-操作-解锁。

使用lock_guard可以简化lock/unlock的写法，同时也更安全，因为lock_guard在构造时会自动锁定互斥量，在退出作用域后进行析构时自动解锁。

死锁
可通过加锁保证同一时刻只有一个线程访问共享资源。但注意不要出现死锁的情况。
死锁：多个线程争夺共享资源导致每个线程都不能取得自己所需的全部资源，从而程序无法向下执行。

xxxxxxxxxxxxxxxxxxx

3条件变量

我们在使用mutex时，一般都会期望加锁不要阻塞，总是能立刻拿到锁，然后尽快访问数据，用完之后尽快解锁，这样才能不影响并发性和性能。
但如果一个线程需要等待一个互斥锁的释放，该线程通常需要轮询该互斥锁是否已被释放，我们也很难找到适当的轮训周期，如果轮询周期太短则太浪费CPU资源，如果轮询周期太长则可能互斥锁已被释放而该线程还在睡眠导致发生延误。

条件变量跟 c++11 没半毛钱，是操作系统实现的。关键在于理解为啥要有它，而且需注意一点，条件变量自身并不包含条件。因为它通常和 if (或者while) 一起用，所以叫条件变量。
换句话说，并发有两大需求，一是互斥，二是等待，互斥是因为多线程存在共享变量，等待是因为线程之间存在依赖。

互斥可通过mutex搞定，而依赖的话。不使用条件变量的话，大多通过轮询搞定。

条件变量，是为了解决等待需求。考虑实现生产者消费者队列，生产者和消费者各是一个线程。一个明显的依赖是，消费者线程依赖生产者线程 push 元素进队列。没有条件变量，你会怎么实现消费者呢？让消费者线程一直轮询队列（需要加 mutex)。如果是队列里有值，就去消费；如果为空，要么是继续查( spin 策略)，要么 sleep 一下，让系统过一会再唤醒你，你再次查。可以想到，无论哪种策略，都不通用，要么费 cpu，要么线程过分 sleep，影响该线程的性能。有条件变量后，你就能用事件模式了。上面的消费者线程，发现队列为空，就告诉操作系统，我要 wait，一会肯定有其他线程发信号来唤醒我的。这个『其他线程』，实际上就是生产者线程。生产者线程 push 队列之后，则调用 signal，告诉操作系统，之前有个线程在 wait，你现在可以唤醒它了。上述两种等待方式，前者是轮询(poll)，后者是事件(event)。一般来说，事件方式比较通用，性能不会太差(但存在切换上下文的开销)。轮询方式的性能，就非常依赖并发 pattern，也特别消耗 cpu。考虑到操作系统尽量为通用设计，而且当年的 cpu 只有单核，不太够用，支持事件模式是必然选择，条件变量不可或缺。

条件变量的作用：是c++11提供的另外一种用于等待的同步机制，它能阻塞一个或者多个线程，直到收到另外一个线程发出的通知或者超时，才会唤醒当前阻塞的线程。

参考文章：C++多线程并发（三）—线程同步之条件变量

4 生产者-消费者线程模型

#include "iostream"
#include "thread"
#include "mutex"
#include "condition_variable"
#include "queue"

using namespace std;

mutex mtx;  //定义互斥锁，保证线程间互斥
condition_variable cv; //定义条件变量，保证线程之间的同步操作

class Queue   //定义生产者和消费者的类，生产一个，就通知消费者消费一个；消费完了，再通知生产者生产。
{
public:
    void put(int val)
    {
        unique_lock<mutex> lck(mtx); //锁
        while(!que.empty()) //que不为空时，生产者线程进入等待，把锁释放掉。
        {
            cv.wait(lck); //lck.lock() lck.unlock()
        }
        que.push(val);
        /* notify_one:通知另外的一个线程的 notify_all:通知其它所有线程的 通知其它所有的线程，我生产了一个物品，你们赶紧消费吧 其它线程得到该通知，就会从等待状态 =》 阻塞状态 =》 获取互斥锁才能继续执行 */
        cv.notify_all();
        cout<<"produce:"<<val<<endl;
    }

    int get()
    {
        unique_lock<mutex> lck(mtx);
        while (que.empty()) //队列为空，消费者线程进入等待，把互斥锁mutex释放掉。等待生产者生产。
        {
            cv.wait(lck);
        }
        int val = que.front();
        que.pop();
        cv.notify_all();// 通知其它线程我消费完了，赶紧生产吧
        cout<<"consume:"<<val<<endl;
        return val;
    }
private:
    queue<int> que;
};

void prodecer(Queue * que)
{
    for(int i=0;i<10;i++)
    {
        que->put(i);
        std::this_thread::sleep_for(std::chrono::microseconds(100));
    }
}

void consumer(Queue * que)
{
    for(int i=0;i<10;i++)
    {
        que->get();
        std::this_thread::sleep_for(std::chrono::microseconds(100));
    }
}

int main()
{
    Queue que;
    thread t1(prodecer,&que);
    thread t2(consumer,&que);
    t1.join();
    t2.join();
    return 0;
}

关于wait() 的解释：
1.无条件等待：

void wait (unique_lock<mutex>& lck);

定义锁为lck， 当前线程调用wait() 后将被阻塞，此时wait() 会自动调用unlock() 释放该锁，保证其他线程可以继续执行。直到另一个线程调用notify 唤醒当前线程，wait() 函数会自动调用lock()函数，使得当前线程执行。
2.有条件等待

template <class Predicate>
void wait (unique_lock<mutex>& lck, Predicate pred);

基本思路同上，只有当pred条件为false时，调用wait() 函数才会阻塞当前线程。收到notify时，只有pred为true时才会执行该线程。

同理对于wait_for() 函数，
1.pre为true，立即唤醒线程。
2.只有ped条件为false时，且没超时就继续阻塞，超时就唤醒。
3.当其他线程使用notify时，取决于pre的状态，若为false，则为虚假唤起，线程依然阻塞。

（不过 wait_for可以指定一个时间段，在当前线程收到通知或者指定的时间 rel_time 超时之前，该线程都会处于阻塞状态。而一旦超时或者收到了其他线程的通知，wait_for返回，剩下的处理步骤和 wait()类似）可见下面代码

#include <iostream>           // std::cout
#include <thread>             // std::thread
#include <chrono>             // std::chrono::seconds
#include <mutex>              // std::mutex, std::unique_lock
#include <condition_variable> // std::condition_variable, std::cv_status

std::condition_variable cv;

int value;

void do_read_value()
{
    std::cin >> value;
    cv.notify_one();
}

int main ()
{
    std::cout << "Please, enter an integer (I'll be printing dots): \n";
    std::thread th(do_read_value);

    std::mutex mtx;
    std::unique_lock<std::mutex> lck(mtx);
    while (cv.wait_for(lck,std::chrono::seconds(3)) == std::cv_status::timeout) {
        std::cout << '.';
        std::cout.flush();
    }

    std::cout << "You entered: " << value << '\n';
    th.join();
    return 0;
}

关于notify

std::condition_variable::notify_one()

唤醒某个等待的线程，若没有等待的线程，则该函数什么也不做。若有多个等待的线程，则唤醒是不确定的。

std::condition_variable::notify_all()

唤醒所有的等待（wait）线程

关于cv_status

cv_status::no_timeout

wait_for 或者 wait_until 没有超时，即在规定的时间段内线程收到了通知。

cv_status::timeout

wait_for 或者 wait_until 超时