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;
}你会发现主线程已经结束了
2.4 异步执行的特性
#include <iostream>
#include <thread>
#include <chrono>
#include <vector>
void threadFunction(int id) {
// 模拟线程的工作负载
int i=id;
if (id%2==0)id=id*3;
std::this_thread::sleep_for(std::chrono::seconds(id));
std::cout << "Thread " << i << " finished its work." << std::endl;
}
int main() {
const int numThreads = 5;
std::vector<std::thread> threads;
// 创建多个线程
for (int i = 0; i < numThreads; ++i) {
threads.emplace_back(threadFunction, i + 1);
}
// 等待所有线程完成
for (auto& thread : threads) {
thread.join();
}
std::cout << "All threads have finished." << std::endl;
return 0;
}
//就会清晰的发现 结果
Thread 1 finished its work.
Thread 3 finished its work.
Thread 5 finished its work.
Thread 2 finished its work.
Thread 4 finished its work.
windows按工作时间来的，不是按顺序！！！