C++并发以及多线程的秘密

1.基础概念 并发（Concurrency）

并发是指在同一时间段内，多个任务看起来像是同时执行的。并发并不一定意味着真正的同时执行，它可以是通过时间片轮转等方式在多个任务之间快速切换，让用户感觉多个任务在同时进行。并发可以通过多线程、多进程等方式实现。

线程（Thread）

线程是进程中的一个执行单元，是 CPU 调度和分派的基本单位。一个进程可以包含多个线程，这些线程共享进程的内存空间和系统资源，但每个线程有自己独立的栈空间和执行上下文。线程之间的通信和数据共享比进程更加方便和高效。比如，在一个浏览器进程中，可能会有负责渲染页面的线程、处理网络请求的线程等。

多线程（Multithreading）

多线程是实现并发的一种方式，它允许一个进程中同时存在多个线程，这些线程可以并行（在多核 CPU 上）或并发（在单核 CPU 上）执行不同的任务，从而提高程序的执行效率和响应速度。

进程（Process）

进程是程序在操作系统中的一次执行过程，是系统进行资源分配和调度的基本单位。每个进程都有自己独立的内存空间、系统资源（如文件描述符等）和执行上下文。不同进程之间相互独立，一个进程的崩溃通常不会影响其他进程。例如，当你打开一个浏览器、一个文本编辑器时，它们分别对应着不同的进程。(一个进程有一个主线程)

2 .操作多线程 2.1 创造线程

在 C++ 中，<thread> 库提供了用于管理线程的类和函数，它是 C++11 标准引入的，用于支持多线程编程

默认构建：

std::thread t;

带执行函数的构造函数：创建一个新线程并执行指定的函数。可以传递参数给该函数

#include <iostream> #include <thread> void func(int a) { std::cout << "线程执行，参数: " << a << std::endl; } int main() { std::thread t(func, 42); t.join(); // 等待线程执行完毕 return 0; }

记得 线程只能出传入右值

右值引用与线程

#include <iostream> #include <thread> #include <string> // 线程函数，接受一个字符串参数 void threadFunction(std::string str) { std::cout << "线程接收到的字符串: " << str << std::endl; } int main() { // 使用右值引用传递临时对象给线程 std::thread t(threadFunction, std::string("Hello, Thread!")); // 等待线程执行完毕 t.join(); return 0; }

左值引用与线程

左值引用用于引用一个已经存在的对象。在多线程编程中，如果需要在线程函数中修改外部对象，或者避免对象的拷贝，可以使用左值引用

#include <iostream> #include <thread> #include <string> // 线程函数，接受一个字符串的左值引用 void threadFunction(std::string& str) { str += " - Modified by thread"; std::cout << "线程修改后的字符串: " << str << std::endl; } int main() { std::string message = "Initial message"; // 使用左值引用传递对象给线程 std::thread t(threadFunction, std::ref(message));//ref提取地址 // 等待线程执行完毕 t.join(); std::cout << "主线程看到的修改后的字符串: " << message << std::endl; return 0; }

因为线程只能右值传递,所有以引用形式传递对象（值传递和引用之间的区别 你可以理解为复制和对地址操作）关于右值的话：c++新特性之 左右值 lambda 以及“for”-CSDN博客

成员函数

普通：

#include <iostream> #include <thread> class MyClass { public: // 普通成员函数 void memberFunction(int value) { std::cout << "线程正在执行成员函数，传入的值是: " << value << std::endl; } }; int main() { MyClass obj; int param = 42; // 创建线程并引用类的普通成员函数 std::thread t(&MyClass::memberFunction, &obj, param); // 等待线程执行完毕 t.join(); return 0; }

静态：

#include <iostream> #include <thread> class MyClass { public: // 普通成员函数 void memberFunction(int value) { std::cout << "线程正在执行成员函数，传入的值是: " << value << std::endl; } }; int main() { MyClass obj; int param = 42; // 创建线程并引用类的普通成员函数 std::thread t(&MyClass::memberFunction, &obj, param); // 等待线程执行完毕 t.join(); return 0; } 2.2成员函数

join函数

join() 函数的作用是阻塞当前线程，直到被调用 join() 的 std::thread 对象所代表的线程执行完毕。也就是说，当在一个线程（通常是主线程）中调用另一个线程对象的 join() 方法时，当前线程会暂停执行，等待目标线程执行结束后才会继续执行后续代码。

#include <iostream> #include <thread> // 线程函数 void threadFunction() { for (int i = 0; i < 5; ++i) { std::cout << "子线程输出: " << i << std::endl; } } int main() { std::thread t(threadFunction); std::cout << "主线程等待子线程执行完毕..." << std::endl; t.join(); // 主线程阻塞，等待子线程执行完毕 std::cout << "子线程执行完毕，主线程继续执行。" << std::endl; return 0; }

detch 函数

detach() 函数用于将 std::thread 对象所代表的线程与该对象分离，让线程在后台独立执行。分离后的线程在执行完毕后会自动释放资源，而不需要主线程调用 join() 来等待它结束。一旦线程被分离，就无法再通过 join() 来等待它，也不能再使用该 std::thread 对象来管理这个线程。

#include <iostream> #include <thread> #include <chrono> // 线程函数 void detachedThreadFunction() { std::this_thread::sleep_for(std::chrono::seconds(2)); std::cout << "分离的线程执行完毕。" << std::endl; } int main() { std::thread t(detachedThreadFunction); std::cout << "主线程不等待分离的线程，继续执行。" << std::endl; t.detach(); // 分离线程 std::cout << "主线程继续执行其他任务..." << std::endl; // 主线程可以继续执行其他任务，不需要等待分离的线程 return 0; } 2.3detach陷阱

你考虑一下 上面是不是陷入陷阱？

应该是的 因为

#include <iostream> #include <thread> #include <chrono> // 线程函数 void detachedThreadFunction() { std::this_thread::sleep_for(std::chrono::seconds(2));//等待2s才进行 std::cout << "分离的线程执行完毕。" << std::endl; } int main() { std::thread t(detachedThreadFunction); std::cout << "主线程不等待分离的线程，继续执行。" << std::endl; t.detach(); // 分离线程 std::cout << "主线程继续执行其他任务..." << std::endl; // 让主线程等待足够长的时间，确保分离的线程执行完毕 std::this_thread::sleep_for(std::chrono::seconds(3)); return 0; }

你会发现主线程已经结束了