c++多线程并发的原理及实现

一、并发、线程、进程的基本概念和综述

线程：线程是操作系统能够进行CPU调度的最小单位，它被包含在进程之中，一个进程可包含单个或者多个线程。可以用多个线程去完成一个任务，也可以用多个进程去完成一个任务，它们的本质都相当于多个人去合伙完成一件事。

多线程并发：多线程是实现并发(双核的真正并行或者单核机器的任务切换都叫并发）的一种手段，多线程并发即多个线程同时执行,一般而言，多线程并发就是把一个任务拆分为多个子任务，然后交由不同线程处理不同子任务,使得这多个子任务同时执行。

C++多线程并发： （简单情况下）实现C++多线程并发程序的思路如下：将任务的不同功能交由多个函数分别实现，创建多个线程，每个线程执行一个函数，一个任务就这样同时分由不同线程执行了。

不要过多纠结多线程与多进程、并发与并行这些概念 （这些概念都是相当于多个人去合伙完成一件事），会用才是王道，理解大致意思即可,想要深入了解可阅读本文“延伸拓展”章节。

我们通常在何时使用并发? 程序使用并发的原因有两种，为了关注点分离（程序中不同的功能，使用不同的线程去执行），或者为了提高性能。当为了分离关注点而使用多线程时，设计线程的数量的依据，不再是依赖于CPU中的可用内核的数量，而是依据概念上的设计（依据功能的划分）。

知道何时不使用并发与知道何时使用它一样重要。 不使用并发的唯一原因就是收益（性能的增幅）比不上成本（代码开发的脑力成本、时间成本，代码维护相关的额外成本）。运行越多的线程，操作系统需要为每个线程分配独立的栈空间，需要越多的上下文切换，这会消耗很多操作系统资源，如果在线程上的任务完成得很快，那么实际执行任务的时间要比启动线程的时间小很多，所以在某些时候，增加一个额外的线程实际上会降低，而非提高应用程序的整体性能，此时收益就比不上成本。

进程：可执行的程序运行起来了，就叫做创建了一个线程，即运行起来的可执行

多线程（并发）

多线程并不是越多越好，每个线程都需要一个独立的堆栈空间，线程保存的越多的中间状态；

多线程之间的切换需要花费大量的时间。

总结

a)线程是用来执行代码的

b)把线程这个东西理解成一个条代码的执行通路，一个新的线程代表一条新的通路。

c)一个进程包含一个主线程，主线程随着进程默默启动并运行，我们可以通过编码来创建多个其他线程（非主线程）。但创建的线程数量不要超过200-300个，具体是每个人情况而定；

d)因为主线程是自动启动的，所以一个进程至少包含一个线程，进程与线程类似父子关系；

e）多线程可以同时干多件事情，所以运行速度快，具体速度具体程序评估。

二、并发的实现方法

实现并行的手段：a）通过多个进程实现并发；b）在单独进程中建立多个线程来实现并发，自己写代码来创建了除主线程之外的其他线程

2.1多进程并发

进程间通信（同一个电脑）：管道，文件，消息对列，共享内存；

进程间通信（不同一个电脑：socket通信技术

2.2多线程并发

线程：轻量级进程，每个线程有自己独立运行路径，但是一个进程中所有线程共享地址空间（共享内存）；

全局变量，指针，引用都可在线程之间进行传递，所以：使用多线程开销远远小于多进程；

共享内存带来的新问题：数据一致性问题，线程A、线程B同时使用一个数据 。

三、多线程并发的实现

**步骤：**程序运行起来，生成一个进程，该进程所属的主线程开始自动运行；主线程从主函数返回，则整个进程执行完毕。

主线程从main()函数开始执行，那么我们自己创建的线程，也需要从一个函数开始运行，一旦函数运行完毕，回到主线程；

整个进程是都执行完毕的标志是主线程是否执行完毕，如果主线程执行完毕了，就代表了整个进程都执行完毕了。此时，一般情况下，如果其他子线程还没执行完毕，那么这些子线程也会被操作系统强行终止。所以，一般情况下，我们得到一个结论，如果大家向保持子线程的运行状态，那么一定要保证主线程已知运行，不要让主线程运行完毕。
1、实现的具体过程

a)包含一个头文件thread

b）编写一个初始函数

c)main()中开始写代码

必须明确一点：有两个线程在跑，相当于整个程序的执行有两条线在同时走，所以可以干两件事。

1.1）thread:是标准库里的类

1.2)join()：加入，汇合，说白了就是阻塞主线程，让主线程等待子线程执行完毕，然后子线程与主线程汇合。

1.3）detach():分离，传统多线程程序需要等待子线程执行完毕，然后再退出，detach能够实现主线程运行主线程，子线程运行子线程，互不干扰，主线程也不必等子线程运行结束。

总之，使用C++线程库启动线程，可以归结为构造std::thread对象。当线程启动后，一定要在和线程相关联的std::thread对象销毁前，对线程运用join()或者detach()方法。
join()与detach()都是std::thread类的成员函数，是两种线程阻塞方法，两者的区别是是否等待子线程执行结束。
新手先把join()弄明白就行了，然后就可以去学习后面的章节，等过段时间再回头来学detach()。
等待调用线程运行结束后当前线程再继续运行，例如，主函数中有一条语句th1.join(),那么执行到这里，主函数阻塞，直到线程th1运行结束，主函数再继续运行。

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

#include<iostream>
#include<thread>
using namespace std;
void proc(int &a)
{
   
    cout << "我是子线程,传入参数为" << a << endl;
    cout << "子线程中显示子线程id为" << this_thread::get_id()<< endl;
}
int main()
{
   
    cout << "我是主线程" << endl;
    int a = 9;
    thread th2(proc,ref(a));//第一个参数为函数名，第二个参数为该函数的第一个参数，如果该函数接收多个参数就依次写在后面。此时线程开始执行。
    cout << "主线程中显示子线程id为" << th2.get_id() << endl;
    th2.join()；//此时主线程被阻塞直至子线程执行结束。
    return 0;
}

调用join()会清理线程相关的存储部分，这代表了join()只能调用一次。使用joinable()来判断join()可否调用。同样，detach()也只能调用一次，一旦detach()后就无法join()了，有趣的是，detach()可否调用也是使用joinable()来判断。

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

直观的表现就是若A片段执行完才能执行B片段，线程1执行A片段，线程2执行B片段，在B片段执行前申请锁l，在A片段执行结束后解锁l；未申请到锁l即A片段还未执行完，线程1等待线程2执行。A片段解锁了B片段才能申请到锁，保证了A片段执行结束了B片段才能运行，称之为同步；

互斥就是保证资源同一时刻只能被一个进程使用；互斥是为了保证数据的一致性，如果A线程在执行计算式A的时候，某个量被B线程改掉了，这可能会出现问题，于是要求资源互斥，我在用它你就不能用，等我用完了你再用，我们彼此互不干扰。
2.2 互斥锁
互斥量mutex就是互斥锁，加锁的资源支持互斥访问；
2.3 读写锁
shared_mutex读写锁把对共享资源的访问者划分成读者和写者，多个读线程能同时读取共享资源，但只有一个写线程能同时读取共享资源
2.4 lock()与unlock()
shared_mutex通过lock_shared，unlock_shared进行读者的锁定与解锁；通过lock，unlock进行写者的锁定与解锁。
首先需要#include（std::mutex和std::lock_guard都在头文件中声明。）
然后需要实例化std::mutex对象；
需要在进入临界区之前对互斥量加锁，退出临界区时对互斥量解锁；

#include<iostream>
#include<thread>
#include<mutex>
using namespace std;
mutex m;//实例化m对象，不要理解为定义变量
void proc1(int a)
{
   
    m.lock();
    cout << "proc1函数正在改写a" << endl;
    cout << "原始a为" << a << endl;
    cout << "现在a为" << a + 2 << endl;
    m.unlock();
}

void proc2(int a)
{
   
    m.lock();
    cout << "proc2函数正在改写a" << endl;
    cout <<