std::thread
std::thread用来创建一个线程：
#include <thread>
void threadFun(int temp)
{
int i = 0;
}
int main()
{
std::thread t1(threadFun, 100);
t1.join();
//t1.detach();
return 0;
}
创建了一个名为t1的线程，调用join方法阻塞等待线程退出，也可以调用detach使线程处于游离态，参考Linux多线程，可以观察到，必须调用这两个方法中的一个，不然会报错：
看看thread析构函数：
~thread() noexcept {
if (joinable()) {
_STD terminate();
}
}
_NODISCARD bool joinable() const noexcept {
return _Thr._Id != 0;
}
void join() {
if (!joinable()) {
_Throw_Cpp_error(_INVALID_ARGUMENT);
}
if (_Thr._Id == _Thrd_id()) {
_Throw_Cpp_error(_RESOURCE_DEADLOCK_WOULD_OCCUR);
}
if (_Thrd_join(_Thr, nullptr) != _Thrd_success) {
_Throw_Cpp_error(_NO_SUCH_PROCESS);
}
_Thr = {};
}
void detach() {
if (!joinable()) {
_Throw_Cpp_error(_INVALID_ARGUMENT);
}
_Check_C_return(_Thrd_detach(_Thr));
_Thr = {};
}
当thread对象被创建时，会给线程分配一个线程id(不为0)，join和detach函数每次执行时会将_Thr对象置空，也就是将线程id置为0，当thread对象析构时，调用joinable函数发现线程id不为0就会terminate终止程序。
std::mutex
有关mutext相关知识可以参考Linux线程同步
mutex
有lock,try_lock,unlock三个方法。
recursive_mutex
有lock,try_lock,unlock三个方法。
它是可递归使用的互斥量，mutext对同一线程多次加锁会导致死锁，而recursive_mutex可以被同一个线程多次加锁而不会导致死锁。
#include <iostream>
#include <thread>
#include <mutex>
std::recursive_mutex rmtx; // 定义一个可递归使用的互斥量对象
void printMessage(const std::string& message, int count) {
std::lock_guard<std::recursive_mutex> lock(rmtx); // 创建一个锁定互斥量的对象
if (count > 0) {
std::cout << message << " (" << count << ")" << std::endl;
printMessage(message, count - 1); // 递归调用
}
}
int main() {
std::thread t1(printMessage, "Hello", 3);
t1.join();
return 0;
}
printMessage方法中递归调用会重复加锁，递归退出会重复解锁。
需要注意的是，尽管std::recursive_mutex允许同一个线程多次加锁，但是相应地也必须多次解锁，每次解锁都要和加锁操作配对使用。否则，如果解锁次数多于加锁次数，那么仍然会导致死锁的问题
lock_guard
#include <iostream>
#include <thread>
#include <mutex>
std::mutex mtx; // 定义一个互斥量对象
void printMessage(const std::string& message) {
std::lock_guard<std::mutex> lock(mtx); // 创建一个锁定互斥量的对象
std::cout << message << std::endl;
// 在作用域结束时，std::lock_guard对象会自动调用析构函数进行解锁操作
}
int main() {
std::thread t1(printMessage, "Hello");
std::thread t2(printMessage, "World");
t1.join();
t2.join();
return 0;
}
lock_guard使用了RAII思想(资源获取就是初始化)，构造函数里加锁，析构函数里面解锁，使用起来比较方便。
unique_lock
相比于lock_guard，提供了更精细的控制，感兴趣的可以看看源码
condition_variable
#include <iostream>
#include <thread>
#include <mutex>
std::mutex mtx; // 定义一个互斥量对象
std::condition_variable cv; // 定义一个条件变量对象
bool isReady = false; // 全局变量，用于表示条件是否满足
void waitForSignal() {
std::unique_lock<std::mutex> lock(mtx); // 创建一个锁定互斥量的对象
// 阻塞等待条件变量isReady为true
cv.wait(lock, [] { return isReady; });
// 条件满足后继续执行
std::cout << "Received the signal" << std::endl;
}
void sendSignal() {
std::this_thread::sleep_for(std::chrono::seconds(2)); // 延迟2秒钟，模拟耗时操作
{
std::lock_guard<std::mutex> lock(mtx); // 创建一个锁定互斥量的对象
isReady = true; // 设置条件为true
}
cv.notify_one(); // 唤醒一个等待线程
}
int main() {
std::thread t1(waitForSignal);
std::thread t2(sendSignal);
t1.join();
t2.join();
return 0;
}
条件变量可以用来控制当一个线程满足某种条件是，唤醒(notify_one)等待(wait)在条件变量上的其他线程
timed_mutex
#include <iostream>
#include <thread>
#include <mutex>
std::timed_mutex mtx; // 定义一个 timed_mutex 对象
void doWork() {
std::cout << "Thread " << std::this_thread::get_id() << " trying to lock" << std::endl;
if (mtx.try_lock_for(std::chrono::seconds(2))) {
std::cout << "Thread " << std::this_thread::get_id() << " locked successfully" << std::endl;
std::this_thread::sleep_for(std::chrono::seconds(3)); // 模拟持有锁并进行一些操作
mtx.unlock(); // 解锁
std::cout << "Thread " << std::this_thread::get_id() << " unlocked" << std::endl;
}
else {
std::cout << "Thread " << std::this_thread::get_id() << " failed to lock" << std::endl;
}
}
int main() {
std::thread t1(doWork);
std::thread t2(doWork);
t1.join();
t2.join();
return 0;
}
在上述示例中，定义了一个 std::timed_mutex 对象 mtx。doWork() 函数尝试在 2 秒的超时时间内获取互斥量的锁，如果成功获取锁，则持有锁并进行一些操作，然后解锁。如果在超时时间内无法获得锁，则放弃锁的获取。
std::timed_mutex 的主要方法是 try_lock_for()，该方法用于尝试在指定的时间段内获取互斥量的锁。如果在超时时间内成功获取锁，则返回 true，否则返回 false。
std::timed_mutex 的使用场景通常是在需要获取锁时，希望在一定时间内等待并放弃获取锁的线程，以避免长时间阻塞。它提供了一种更灵活的方式来控制线程对共享资源的访问。
recursive_timed_mutex
#include <iostream>
#include <chrono>
#include <mutex>
#include <thread>
std::recursive_timed_mutex mtx; // 定义一个可递归加锁的互斥量对象
void recursiveFunc(int count)
{
std::unique_lock<std::recursive_timed_mutex> lock(mtx, std::defer_lock); // 创建 unique_lock 对象，但不立即锁定互斥量
if (lock.try_lock_for(std::chrono::milliseconds(100))) { // 尝试锁定互斥量，等待最多100毫秒
std::cout << "Thread " << count << " acquired the lock." << std::endl;
// 递归调用，多次获取锁
if (count > 0) {
recursiveFunc(count - 1);
}
lock.unlock(); // 解锁互斥量
std::cout << "Thread " << count << " released the lock." << std::endl;
} else {
std::cout << "Thread " << count << " failed to acquire the lock within the timeout." << std::endl;
}
}
int main()
{
std::thread t1(recursiveFunc, 3);
t1.join();
return 0;
}
在上述示例中，定义了一个 std::recursive_timed_mutex 对象 mtx。在 recursiveFunc() 函数内部，通过创建一个 std::unique_lock 对象 lock 并使用 std::defer_lock 参数延迟锁定互斥量。然后，使用 try_lock_for() 函数尝试在最多 100 毫秒的时间内锁定互斥量。如果成功获取锁，则打印一条获取锁成功的消息，并递归调用 recursiveFunc() 函数来实现多次加锁。在每次加锁完成后，需要手动解锁。
总之，std::recursive_timed_mutex 类型提供了可递归加锁的互斥量机制，并且支持超时功能。它可以在某些场景下更方便地处理线程间的竞争和互斥问题。需要注意的是，在使用递归互斥量时需要小心避免出现死锁情况。
