【C++并发编程】（一）基本概念

C++并发编程

进程、线程、串行、并行和并发

进程（Process）： 进程是操作系统进行资源分配和调度的基本单位，它拥有独立的内存空间和系统资源，负责执行一个特定的程序或任务。

CPU从硬盘中读取程序到内存中，得到一个可执行程序实例就是进程。

线程（Thread）： 线程是操作系统能够进行运算调度的最小单位，它被包含在进程中，是进程中的实际运作单位，使用进程所拥有的资源，并由进程中的一个执行序列（指定进程计算的顺序）来执行。

【【操作系统】进程和线程的区别-哔哩哔哩】 https://b23.tv/JMadq64

串行（Serial Execution）： 串行执行意味着在一个时间段内计算机只执行一个任务。例如，在一个单核CPU上，任务只能一个接一个地执行。

并行（Parallel Execution）： 并行执行意味着多个任务可以在同一时间点被执行。这通常发生在多核或多处理器的计算机上，每个核心或处理器都可以独立地执行任务。

并发（Concurrent Execution）： 并发是在极小的时间段内执行多个任务。并行是并发的一种实现方式。除此之外，还可以通过在同一时间段内，交替执行一个多个任务实现并发，只要交替的速度够快，在宏观上看起来就像是并行的。

多线程与多进程并发

---

引例：假设一个餐厅需要为客人做晚餐，有以下方案：
非并发

• 串行: 一个厨师（单进程）按顺序做所有菜：先做前菜，然后做主菜，最后做甜点（单线程）。

并发：

• 多线程并发 ：一个厨师（单进程）同时做多个菜：在做前菜的过程中准备主菜的材料，然后在主菜烹饪时开始准备甜点。（多线程）
• 多进程并发：（1）多个厨师（多进程）各自按顺序（单线程）做分配到的菜。 或者（2）多个厨师（多进程）各自同时（多线程）做多个菜。

---

多线程程序和多进程程序都可以在多个CPU上运行，并且都可以利用多核CPU的并行处理能力来提高程序的执行效率。然而，它们在实现方式和效果上有所不同：

多线程（Multithreading）并发：
多线程并发的线程之间共享相同的进程的资源，可以更方便地共享数据。线程切换的开销较小，通信也较简单。但线程之间共享内存也使得容易出现资源竞争和死锁等问题。

常见应用场景：

• 并行计算：适用于CPU密集型任务，如图像处理、计算密集型算法等。
• 异步编程：适用于IO密集型任务，如网络通信、文件操作等。

多进程（Multiprocessing）并发：
多进程中每个进程有自己独立的内存空间，相互之间不会影响, 稳定性更高。但是，多进程的进程切换开销较大，系统资源消耗相对较高。多进程之间不会共享内存, 进程间通信相对复杂，通常需要使用进程间通信（Inter-Process Communication，IPC）机制。

常见应用场景：

• 服务器编程：适用于需要处理大量客户端请求的服务器，如Web服务器、数据库服务器等。
• 分布式计算：适用于需要利用多台计算机进行协作计算的任务，如MapReduce框架等。

C++并发编程

C++并发编程的原生支持主要包括以下几个方面：

• 线程：C++11引入了标准线程库std::thread，它提供了一组用于创建、管理和同步线程的函数和类。
• 互斥量：互斥量是一种同步原语，用于保护共享资源的并发访问。C++11提供了std::mutex类，它允许开发者在多个线程之间同步对共享资源的访问，以防止数据竞争和不一致性问题。
• 条件变量：条件变量是一种用于线程间同步和通信的机制。C++11中的std::condition_variable类允许一个或多个线程等待某个特定条件的发生，当条件满足时，可以唤醒等待的线程。
• 原子操作：原子操作是不可中断的操作，即在执行过程中不会被其他线程打断。C++11引入了std::atomic模板类，提供了一系列原子操作的函数和类，用于保证在多线程环境中对共享数据的访问是线程安全的。
• 异步任务：C++11还提供了异步计算的支持，允许在不同线程中执行异步任务。std::future和std::promise类用于获取异步操作的结果和设置异步操作的返回值。

C++标准并未对进程间通信提供任何原生支持，所以使用多进程的方式实现，这会依赖与平台相关的API。[1] 在Unix/Linux系统下，可以使用fork()系统调用来创建新的进程，而在Windows系统下，可以使用CreateProcess()等API来实现进程创建。

串行 v.s.并发

下面的两个程序都执行了两个任务 task1()和task2()。第一个程序是串行执行，而第二个程序是并发执行。

• 串行执行：

#include <iostream>
#include <chrono>

void task1() {
    // 模拟耗时操作
    for (int i = 0; i < 50000000; ++i) {
        if (i % 20000000 == 0)
            std::cout << "task1:" << i << std::endl;
    }
}
void task2() {
    // 模拟耗时操作
    for (int i = 50000000; i < 100000000; ++i) {
        if (i % 20000000 == 0)
            std::cout << "task2:"<< i << std::endl;
    }
}

int main() {
    auto start = std::chrono::steady_clock::now(); // 记录开始时间

    // 串行执行任务
    task1();
    task2();

    auto end = std::chrono::steady_clock::now(); // 记录结束时间

    // 计算执行时间
    std::chrono::duration<double> elapsed_seconds = end - start;

    // 输出执行时间
    std::cout << "Elapsed time: " << elapsed_seconds.count() << "s\n";

    return 0;
}

task1:0
task1:20000000
task1:40000000
task2:60000000
task2:80000000
Elapsed time: 0.6456s

• 并发执行:

#include <iostream>
#include <thread>
#include <chrono>


void task1() {
    // 模拟耗时操作
    for (int i = 0; i < 50000000; ++i) {
        if (i % 20000000 == 0)
            std::cout << "task1:" << i << std::endl;
    }
}
void task2() {
    // 模拟耗时操作
    for (int i = 50000000; i < 100000000; ++i) {
        if (i % 20000000 == 0)
            std::cout << "task2:" << i << std::endl;
    }
}

int main() {
    auto start = std::chrono::steady_clock::now(); // 记录开始时间

    // 创建两个线程执行任务
    std::thread t1(task1);
    std::thread t2(task2);

    // 等待两个线程执行完毕
    t1.join();
    t2.join();

    auto end = std::chrono::steady_clock::now(); // 记录结束时间

    // 计算执行时间
    std::chrono::duration<double> elapsed_seconds = end - start;

    // 输出执行时间
    std::cout << "Elapsed time: " << elapsed_seconds.count() << "s\n";

    return 0;
}

task1:0
task2:60000000
task1:20000000
task2:80000000
task1:40000000
Elapsed time: 0.346405s

并发执行可以交替执行两个任务，最终消耗的时间比串行的少。

[1] https://nj.gitbooks.io/c/content/content/chapter1/chapter1-chinese.html