thread 类的简单介绍
在 c++11 之前，涉及到多线程问题，都是和平台相关的，比如 windows 和 linux 下各自有自己的接口，这使得代码的可移植性比较差。在 c++11 中引入了线程库，使得 c++在编程时不需要依赖第三方库了
|------------------------------|------------------------------------------------------------|
| 函数名 | 功能 |
| thread() | 构造一个线程对象，没有关联任何线程函数，即没有启动任何线程 |
| thread(fn,args1,arrgs2, ...) | 构造一个线程对象，并关联线程函数 fn，args1，args2， ... 为线程函数的参数 |
| get_id() | 获取线程 id |
| joinable() | 线程是否还在执行，joinable 代表的是一个正在执行中的线程 |
| join() | 该函数调用后会阻塞线程，当该线程结束后，主线程继续执行 |
| detach() | 在创建线程对象后马上调用，用于把被创建线程与线程对象分离开，分离的线程变成后台线程，创建线程的"死活"就与主线程无关 |
注意：
-
线程是操作系统中的一个概念，线程对象可以关联一个线程，用来控制线程以及获取线程的状态
-
当创建一个线程对象后没有提供一个线程函数，该对象实际没有对应任何线程
#include <thread>
int main()
{
std::thread t1;
cout << t1.get_id() << endl;
return 0;
} -
当创建一个线程对象后，并且给线程关联线程函数，该线程就被启动，与主线程一起运行，线程函数一般情况下可以有三种方式启动：函数指针，lambda 表达式，函数对象
#include <iostream>
using namespace std;
#include <thread>
void ThreadFunc(int a)
{
cout << "Thread1" << a << endl;
}
class TF
{
public:
void operator()()
{
cout << "Thread3" << endl;
}
};
int main()
{
// 线程函数为函数指针
thread t1(ThreadFunc, 10);// 线程函数为lambda表达式thread t2([]{cout << "Thread2" << endl; });
// 线程函数为函数对象 TF tf;thread t3(tf);
t1.join();
t2.join();
t3.join();
cout << "Main thread!" << endl;
return 0;
} -
线程类是防拷贝的，不允许拷贝构造以及赋值，但是可以移动构造和移动赋值，即将一个线程对象关联线程的状态转移给其他线程对象，原线程对象失去对该线程的控制权，变成一个空线程，新线程对象获得该线程的控制权
#include <iostream>
#include <thread>
#include <chrono>// 一个简单的函数，用于线程执行
void do_work(int id) {
std::cout << "Thread " << id << " is working." << std::endl;
std::this_thread::sleep_for(std::chrono::seconds(1));
std::cout << "Thread " << id << " is done." << std::endl;
}int main() {
// 创建一个线程对象
std::thread t1(do_work, 1); // t1 现在关联着一个执行 do_work(1) 的线程// 检查线程是否joinable，即是否有关联的线程 if (t1.joinable()) { std::cout << "Thread t1 is joinable." << std::endl; } // 创建另一个线程对象，使用移动构造函数转移t1的线程控制权 std::thread t2(std::move(t1)); // t1 现在是空的，t2 接管了原来 t1 的线程 // 再次检查t1是否joinable，现在应该不是，因为它已经移动了 if (t1.joinable()) { std::cout << "Thread t1 is joinable after move." << std::endl; } else { std::cout << "Thread t1 is not joinable after move." << std::endl; } // 等待t2关联的线程结束 t2.join(); // 尝试再次join t1，这将导致错误，因为t1不关联任何线程 // t1.join(); // 这将抛出一个std::system_error异常 return 0;}
线程函数参数
线程函数的参数是以值拷贝的方式拷贝到线程栈空间中的，因此，即使线程参数为引用类型，在线程中修改也不能修改外部实参，因为线程参数实际引用的是线程栈的拷贝，不是外部实参
如果想要通过形参改变外部实参时，必须借助 std::ref 函数
ref 就是把参数按照引用方式传递
#include <thread>
#include <iostream>
using namespace std;
void ThreadFunc1(int& x)
{
x += 10;
}
int main()
{
int a = 10;
// 在线程函数中对a修改，不会影响外部实参，因为：线程函数参数虽然是引用方式，但其实际
//引用的是线程栈中的拷贝
thread t1(ThreadFunc1, a);
t1.join();
cout << a << endl;
// 如果想要通过形参改变外部实参时，必须借助std::ref()函数
thread t2(ThreadFunc1, std::ref(a));
t2.join();
cout << a << endl;
return 0;
}
原子性操作库(atomic)
多线程最主要的问题是共享数据带来的问题(即线程安全)，为此 C++11 中引入了原子操作：即不可被中断的一个或一系列操作，C++11 引入原子操作类型，使得线程间数据的同步变得非常高效
普遍的，我们可以使用 atomic 类模板，定义出需要的任意原子类型
atomic<T> t //声明一个类型为 T 的原子类型变量 t
#include <iostream>
using namespace std;
#include <thread>
#include <atomic>
atomic<size_t> sum=0;
void fun(size_t num)
{
for (size_t i = 0; i < num; ++i)
sum++; // 原子操作
}
int main()
{
cout << "Before joining, sum = " << sum << std::endl;
thread t1(fun, 1000000);
thread t2(fun, 1000000);
t1.join();
t2.join();
cout << "After joining, sum = " << sum << std::endl;
return 0;
}
c++中的锁
C++11 标准库中<mutex>头文件提供了多种互斥锁类型，最常用的是 std::mutex
std::mutex mtx; // 声明一个互斥锁
mtx.lock(); // 锁定互斥锁
// 访问或修改共享数据
mtx.unlock(); // 解锁互斥锁
RAII 锁定
c++11 中引入了基于 RAII(资源获取即初始化)的锁定机制，lock_guard 和 unique_lock 是两种常用的 RAII 锁定器
lock_guard 在构造时，自动获取互斥锁，并在析构时自动释放互斥锁，适用于在一个作用域中加锁和解锁，构造线程安全的作用域
#include <mutex>
#include <iostream>
void critical_section(std::mutex& mtx) {
std::lock_guard<std::mutex> lock(mtx); // 自动加锁
// 临界区代码
std::cout << "Critical section" << std::endl;
// 离开作用域时自动解锁
}
int main() {
std::mutex mtx;
critical_section(mtx);
return 0;
}
std::unique_lock 提供了对互斥锁的独占所有权，允许在构造时加锁，在析构时解锁，并且可以在对象生命周期中多次加锁和解锁
#include <mutex>
std::mutex mtx;
void function() {
std::unique_lock<std::mutex> lock(mtx); // 构造时加锁
// 临界区代码
lock.unlock(); // 显式解锁
// 非临界区代码
lock.lock(); // 再次加锁
// 临界区代码
} // 析构时解锁
condition_variable 条件变量
关于条件变量的一些函数
wait 函数
wait： 使当前线程在条件变量上等待，直到被另一个线程唤醒
std::unique_lock<std::mutex> lock(mtx); // 获取互斥锁
cv.wait(lock);
在这个调用中，线程会释放锁并进入等待状态，当另一个线程调用 notify_one 或 notify_all 时，等待的线程会被唤醒，并尝试重新获取互斥锁
带谓词的 wait
cv.wait(lock, []{ return some_condition; });
允许你提供一个谓词(一个返回 bool 值的函数或者 labmda 表达式)，线程只有在谓词为真时才会被唤醒
notify_one 和 notify_all
cv.notify_one();//唤醒等待条件变量的一个线程
cv.notify_all();//唤醒等待条件变量的所有线程