文章详情学习记录

C++学习（十三）

发布时间：2026-09-14 15:35 浏览次数：87 最后更新：2026-09-17 16:05

多线程库 thread 与 mutex 讲解

正文内容

C++ 多线程库 `<thread>`

C++11 引入了多线程支持，通过 <thread> 库，开发者可以轻松地在程序中实现并行处理。

本文将将介绍 <thread> 库的基本概念、定义、语法以及如何使用它来创建和管理线程。

线程是程序执行的最小单元，是操作系统能够进行运算调度的最小单位。

在多线程程序中，多个线程可以并行执行，提高程序的执行效率。

C++ `<thread>` 库概述

<thread> 库是 C++ 标准库的一部分，提供了创建和管理线程的基本功能，它包括以下几个关键组件：

std::thread：表示一个线程，可以创建、启动、等待和销毁线程。
std::this_thread：提供了一些静态成员函数，用于操作当前线程。
std::thread::id：线程的唯一标识符。

创建线程

要创建一个线程，你需要实例化 std::thread 类，并传递一个可调用对象（函数、lambda 表达式或对象的成员函数）作为参数。

#include <iostream>
#include <thread>

void print_id(int id) {
    std::cout << "ID: " << id << ", Thread ID: " << std::this_thread::get_id() << std::endl;
}

int main() {
    std::thread t1(print_id, 1);
    std::thread t2(print_id, 2);
}

启动线程

创建 std::thread 对象后，线程会立即开始执行，你可以调用 join() 方法来等待线程完成。

t1.join();
t2.join();

等待线程完成

join() 方法会阻塞当前线程，直到被调用的线程完成执行。

销毁线程

当线程执行完毕后，你可以使用 detach() 方法来分离线程，或者让 std::thread 对象超出作用域自动销毁。

t1.detach(); // 线程将继续运行，但无法再被 join 或 detach

实例：使用 `<thread>` 创建并行计算

下面是一个使用 <thread> 库实现的并行计算实例，计算两个数的和。

#include <iostream>
#include <thread>

int sum = 0;

void add(int a, int b) {
    sum += a + b;
}

int main() {
    int a = 5;
    int b = 10;

    std::thread t1(add, a, b);
    std::thread t2(add, a, b);

    t1.join();
    t2.join();

    std::cout << "Sum: " << sum << std::endl; // 输出结果：Sum: 30
}

输出结果为：

Sum: 30

以下实例我们将创建两个线程，每个线程都会执行一个简单的函数，该函数打印一个消息并休眠一段时间：

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

// 简单的函数，在线程中执行
void print_message(const std::string& message, int delay) {
    std::this_thread::sleep_for(std::chrono::milliseconds(delay));
    std::cout << message << std::endl;
}

int main() {
    // 创建两个线程，执行 print_message 函数
    std::thread t1(print_message, "Hello from thread 1", 1000);
    std::thread t2(print_message, "Hello from thread 2", 500);

    // 等待线程 t1 完成
    if (t1.joinable()) {
        t1.join();
    }

    // 等待线程 t2 完成
    if (t2.joinable()) {
        t2.join();
    }

    std::cout << "Main thread finished." << std::endl;

    return 0;
}

输出结果为：

Hello from thread 2
Hello from thread 1
Main thread finished.

注意事项

线程安全：在多线程环境中，共享资源需要同步访问，以避免数据竞争。
线程生命周期：确保在线程执行完毕后正确地处理线程对象，避免资源泄露。

类和函数

<thread> 库包含了一系列的类和函数，用于创建、管理和同步线程。

以下是对 C++ <thread> 库的详细介绍:

主要组件

std::thread
std::mutex
std::lock_guard
std::unique_lock
std::condition_variable
stdfuture 和 stdpromise
std::async

std::thread

std::thread 类用于创建和管理线程。

#include <iostream>
#include <thread>

void print_hello() {
    std::cout << "Hello from thread!" << std::endl;
}

int main() {
    std::thread t(print_hello);
    t.join(); // 等待线程 t 结束
    return 0;
}

重要方法

join(): 等待线程结束。
detach(): 将线程置于后台运行，不再等待线程结束。
joinable(): 检查线程是否可被 join 或 detach。

std::mutex

std::mutex 类用于同步对共享资源的访问。

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx; // 创建一个全局 mutex 对象
int shared_resource = 0; // 共享资源

// 线程函数
void increment() {
    std::lock_guard<std::mutex> lock(mtx); // 上锁，保证线程安全
    ++shared_resource;
    std::cout << "Incremented shared_resource to " << shared_resource << std::endl;
    // lock 在 lock_guard 离开作用域时自动释放
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);
    
    t1.join(); // 等待线程 t1 完成
    t2.join(); // 等待线程 t2 完成

    std::cout << "Final value of shared_resource: " << shared_resource << std::endl;

    return 0;
}

std::lock_guard

std::lock_guard 是一个 RAII 风格的锁管理器，用于自动管理锁的生命周期。

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx;

void print_thread_id(int id) {
    std::lock_guard<std::mutex> lock(mtx);
    std::cout << "Thread ID: " << id << std::endl;
}

int main() {
    std::thread t1(print_thread_id, 1);
    std::thread t2(print_thread_id, 2);
    t1.join();
    t2.join();
    return 0;
}

std::unique_lock

stdunique_lock 提供了比 stdlock_guard 更灵活的锁管理。

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx;

void print_thread_id(int id) {
    std::unique_lock<std::mutex> lock(mtx);
    std::cout << "Thread ID: " << id << std::endl;
    lock.unlock(); // 可以手动解锁
    // ... 其他操作
}

int main() {
    std::thread t1(print_thread_id, 1);
    std::thread t2(print_thread_id, 2);
    t1.join();
    t2.join();
    return 0;
}

std::condition_variable

std::condition_variable 用于线程间的等待和通知。

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>

std::mutex mtx;
std::condition_variable cv;
bool ready = false;

void print_id(int id) {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, []{ return ready; });
    std::cout << "Thread ID: " << id << std::endl;
}

void set_ready() {
    std::unique_lock<std::mutex> lock(mtx);
    ready = true;
    cv.notify_all();
}

int main() {
    std::thread t1(print_id, 1);
    std::thread t2(print_id, 2);
    
    std::this_thread::sleep_for(std::chrono::seconds(1));
    set_ready();
    
    t1.join();
    t2.join();
    return 0;
}

stdfuture 和 stdpromise

stdfuture 和 stdpromise 用于线程间的结果传递。

#include <iostream>
#include <thread>
#include <future>

void calculate_square(std::promise<int> && p, int x) {
    p.set_value(x * x);
}

int main() {
    std::promise<int> p;
    std::future<int> f = p.get_future();
    
    std::thread t(calculate_square, std::move(p), 5);
    
    std::cout << "Square: " << f.get() << std::endl;
    
    t.join();
    return 0;
}

std::async

stdasync 用于启动异步任务，并返回一个 stdfuture。

#include <iostream>
#include <future>

int calculate_square(int x) {
    return x * x;
}

int main() {
    std::future<int> result = std::async(calculate_square, 5);
    
    std::cout << "Square: " << result.get() << std::endl;
    
    return 0;
}

C++ 的 <thread> 库为开发者提供了强大的多线程支持。通过本文的介绍，我们应该能够理解线程的基本概念，并学会如何使用 <thread> 库来创建和管理线程。在实际开发中，合理利用多线程可以显著提高程序的性能和响应速度。

C++ 标准库 `<mutex>`

在多线程编程中，确保数据的一致性和线程安全是至关重要的。

C++ 标准库提供了一套丰富的同步原语，用于控制对共享资源的访问。

C++ 标准库中的 <mutex> 头文件提供了一组工具，用于在多线程程序中实现线程间的同步和互斥。

<mutex> 头文件是 C++11 引入的，它包含了用于互斥锁（mutex）的类和函数。互斥锁是一种同步机制，用于防止多个线程同时访问共享资源。

互斥锁（Mutex）是一个用于控制对共享资源访问的同步原语。当一个线程需要访问共享资源时，它会尝试锁定互斥锁。如果互斥锁已经被其他线程锁定，请求线程将被阻塞，直到互斥锁被释放。

基本语法

在 C++ 中，<mutex> 头文件提供了以下主要类：

std::mutex：基本的互斥锁。
std::recursive_mutex：递归互斥锁，允许同一个线程多次锁定。
std::timed_mutex：具有超时功能的互斥锁。
std::recursive_timed_mutex：具有超时功能的递归互斥锁。

实例

1. 使用 `std::mutex`

下面是一个简单的示例，展示了如何在 C++ 中使用 std::mutex 来同步对共享资源的访问。

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx; // 全局互斥锁
int shared_resource = 0;

void increment() {
    for (int i = 0; i < 10000; ++i) {
        mtx.lock(); // 锁定互斥锁
        ++shared_resource;
        mtx.unlock(); // 解锁互斥锁
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);

    t1.join();
    t2.join();

    std::cout << "Final value of shared_resource: " << shared_resource << std::endl;
    return 0;
}

输出结果：

Final value of shared_resource: 20000

2. 使用 `std::recursive_mutex`

递归互斥锁允许同一个线程多次锁定同一个互斥锁。下面是一个使用 std::recursive_mutex 的示例。

#include <iostream>
#include <thread>
#include <mutex>

std::recursive_mutex rmtx; // 创建一个递归 mutex 对象
int shared_resource = 0; // 共享资源

// 递归函数
void recursive_increment(int count) {
    if (count <= 0) return;

    std::lock_guard<std::recursive_mutex> lock(rmtx); // 上锁，确保线程安全
    ++shared_resource;
    std::cout << "Incremented shared_resource to " << shared_resource << " (count = " << count << ")" << std::endl;

    // 递归调用
    recursive_increment(count - 1);
}

int main() {
    std::thread t1(recursive_increment, 3); // 线程 t1 执行 recursive_increment(3)
    std::thread t2(recursive_increment, 3); // 线程 t2 执行 recursive_increment(3)
    
    t1.join(); // 等待线程 t1 完成
    t2.join(); // 等待线程 t2 完成

    std::cout << "Final value of shared_resource: " << shared_resource << std::endl;

    return 0;
}

输出结果：

Incremented shared_resource to 1 (count = 3)
Incremented shared_resource to 2 (count = 2)
Incremented shared_resource to 3 (count = 1)
Incremented shared_resource to 4 (count = 0)
Incremented shared_resource to 5 (count = 3)
Incremented shared_resource to 6 (count = 2)
Incremented shared_resource to 7 (count = 1)
Incremented shared_resource to 8 (count = 0)
Final value of shared_resource: 8

代码解析：

创建 std::recursive_mutex 对象：std::recursive_mutex rmtx; 是一个递归互斥量，允许同一线程多次获得锁。
共享资源：int shared_resource = 0; 是多个线程共同访问的资源。
递归函数 recursive_increment：
- 使用 std::lock_guard<std::recursive_mutex> 对 rmtx 上锁。由于使用的是递归互斥量，同一个线程可以多次获得锁。
- 通过 ++shared_resource 增加共享资源的值。
- 函数自身递归调用，演示了递归函数在多次锁定的情况下如何安全地工作。
创建和运行线程：
- std::thread t1(recursive_increment, 3); 和 std::thread t2(recursive_increment, 3); 分别创建两个线程，它们都会执行 recursive_increment(3)。
- t1.join() 和 t2.join() 等待两个线程执行完毕。

注意事项

确保在每次锁定互斥锁后，都进行解锁操作，以避免死锁。
使用 std::lock_guard 或 std::unique_lock 可以自动管理互斥锁的锁定和解锁，减少出错的可能性。
避免在持有互斥锁的情况下调用可能抛出异常的函数，因为这可能导致死锁。

<mutex> 是 C++ 标准库中一个非常重要的头文件，它为多线程编程提供了基本的同步机制。通过使用互斥锁，我们可以确保对共享资源的访问是安全的，从而避免数据竞争和不一致的问题。

更多说明

1. std::mutex

提供基本的互斥量，确保在同一时刻只有一个线程可以访问共享资源。

#include <mutex>

std::mutex mtx;

void thread_function() {
    std::lock_guard<std::mutex> lock(mtx);
    // 访问共享资源
}

2. std::recursive_mutex

允许同一线程多次获得锁，而不会造成死锁，这对递归函数特别有用。

#include <mutex>

std::recursive_mutex rmtx;

void recursive_function(int count) {
    if (count <= 0) return;
    std::lock_guard<std::recursive_mutex> lock(rmtx);
    // 递归调用
    recursive_function(count - 1);
}

3. std::timed_mutex

提供定时的互斥量，可以在尝试获得锁时设置超时时间。

#include <mutex>
#include <chrono>

std::timed_mutex tm;

void try_lock_for_example() {
    if (tm.try_lock_for(std::chrono::seconds(1))) {
        // 成功获得锁
        tm.unlock();
    } else {
        // 锁获取失败
    }
}

4. std::recursive_timed_mutex

继承自 std::timed_mutex，允许同一线程多次获得锁，同时支持定时功能。

#include <mutex>
#include <chrono>

std::recursive_timed_mutex rtm;

void recursive_timed_function(int count) {
    if (count <= 0) return;
    if (rtm.try_lock_for(std::chrono::seconds(1))) {
        // 成功获得锁
        recursive_timed_function(count - 1);
        rtm.unlock();
    } else {
        // 锁获取失败
    }
}

5. std::lock_guard

一种自动管理 std::mutex 锁的封装器，使用 RAII 风格，确保在作用域结束时自动释放锁。

#include <mutex>

std::mutex mtx;

void function() {
    std::lock_guard<std::mutex> lock(mtx);
    // 访问共享资源
}

6. std::unique_lock

提供比 std::lock_guard 更灵活的锁管理，可以手动释放和重新获得锁，还支持定时锁定。

#include <mutex>
#include <chrono>

std::mutex mtx;

void function() {
    std::unique_lock<std::mutex> lock(mtx);
    // 访问共享资源
    
    // 可以手动释放锁
    lock.unlock();
    
    // 可以重新获得锁
    lock.lock();
    
    // 可以进行定时锁定
    if (lock.try_lock_for(std::chrono::seconds(1))) {
        // 成功获得锁
    }
}

7. std::adopt_lock_t

标志类型，用于指定 std::unique_lock 采用已有的锁。

std::mutex mtx;
std::unique_lock<std::mutex> lock(mtx, std::adopt_lock);

8. std::defer_lock_t

功能：标志类型，用于延迟锁定，初始化时不锁定。

std::mutex mtx;
std::unique_lock<std::mutex> lock(mtx, std::defer_lock);
// 可以在之后的某个时刻调用 lock.lock()

9. std::try_to_lock_t

标志类型，用于尝试锁定而不阻塞。

std::mutex mtx1, mtx2;
std::unique_lock<std::mutex> lock1(mtx1, std::try_to_lock);
std::unique_lock<std::mutex> lock2(mtx2, std::try_to_lock);

if (lock1 && lock2) {
    // 成功获得两个锁
}

10. std::shared_mutex

C++17引入的一个同步原语，标准库中提供。它设计用于实现读写锁（Read-Write Lock）机制。允许多个线程同时拥有读（共享）锁，但在任何时间点上只允许一个线程拥有写（独占）锁。与之相似的还有shared_timed_mutex (共享超时互斥锁)

两种访问级别：共享、独占

独占锁定（Exclusive Locking）：

lock()：以独占方式锁定互斥量。如果互斥量已经被锁定（无论是共享还是独占），当前线程将阻塞，直到互斥量变为可用。

try_lock()：尝试以非阻塞的方式以独占方式锁定互斥量。如果互斥量当前未被任何线程锁定，它将锁定互斥量并立即返回true。如果互斥量已被锁定（无论是共享还是独占），它将不会阻塞当前线程，而是立即返回false。

unlock()：释放锁。当一个线程完成了对共享资源的独占访问，它应该调用这个操作来释放独占锁。这将使互斥量变为未锁定状态，其他线程可以尝试锁定互斥量。

共享锁定（Shared Locking）：

lock_shared()：尝试以共享方式锁定互斥量。如果互斥量已经被其他线程以共享方式锁定，当前线程也将获得锁定权限，可以继续执行。如果互斥量被独占锁定，则当前线程将阻塞，直到互斥量变为可用。

try_lock_shared()：这个操作会尝试以非阻塞的方式以共享方式锁定互斥量。如果互斥量当前可用（无论是完全未锁定，还是已被其他线程以共享方式锁定），它将锁定互斥量并立即返回true。如果互斥量被独占锁定，它将不会阻塞当前线程，而是立即返回false。

unlock_shared()：当一个线程完成了对共享资源的访问，它应该调用这个操作来释放共享锁。只有当所有持有共享锁的线程都释放了锁，互斥量才会变为未锁定状态。

#include <iostream>
#include <shared_mutex>
#include <string>
#include <thread>

std::shared_mutex mutex;
int shared_data = 0;

void reader_function(int id) {
    mutex.lock_shared();
    // 在这里读取 shared_data
    std::cout << "Reader " << id << " sees shared_data = " << shared_data << std::endl;
    mutex.unlock_shared();
}

void writer_function() {
    mutex.lock();
    // 修改 shared_data
    shared_data = 42;
    std::cout << "Writer has modified shared_data to " << shared_data << std::endl;
    mutex.unlock();
}

int main() {
    std::thread readers[10];
    for (int i = 0; i < 10; ++i) {
        readers[i] = std::thread(reader_function, i);
    }

    std::thread writer(writer_function);

    for (auto& reader : readers) {
        reader.join();
    }
    writer.join();

    return 0;
}

std::shared_mutex的优势在于它提供了一种有效的方式来处理读多写少的并发场景.

关于std::once_flag

笔记记录一下std::once_flag。这是 C++11 引入的一个同步原语，主要用于确保某个特定的函数只被执行一次，即使在多线程环境中也能保证这一点。适合一次性初始化场景，且很高效。

基本概念

std::once_flag 通常与 std::call_once() 函数一起使用，它们共同确保在多线程环境中某段代码只执行一次。这在实现单例模式、一次性初始化等场景中非常有用。

#include <mutex>

基本用法

std::once_flag flag;
std::call_once(flag, []() {
    // 这里的代码只会执行一次
});

详细特性

（1）线程安全：std::once_flag 保证了在多线程环境中的安全性。

（2）无状态：once_flag 本身不存储任何状态信息。

（3）不可复制或移动：once_flag 既不能被复制也不能被移动。

（4）与 std::call_once() 配合：必须与 std::call_once() 函数一起使用才能发挥作用。

实现原理

std::once_flag通常在内部使用原子操作来实现。它包含一个原子标志，用于指示关联的函数是否已经被调用过。这确保了在多线程环境下，使用std::call_once调用的函数只会执行一次，避免竞态条件和数据竞争。

示例：单例模式实现

std::once_flag 确保在多线程环境中某段代码只执行一次，这在实现单例模式的时候非常有用。

这里举个使用 std::once_flag 实现线程安全的单例模式的例子。

#include <iostream>
#include <mutex>
#include <thread>
#include <memory>

class Singleton {
private:
    Singleton() { std::cout << "Singleton constructed\n"; }

    static std::unique_ptr<Singleton> instance;
    static std::once_flag initInstanceFlag;
    static std::mutex mutex;

public:
    ~Singleton() { std::cout << "Singleton destructed\n"; }

    static Singleton& getInstance() {
        std::call_once(initInstanceFlag, []() {
            instance.reset(new Singleton());
        });
        return *instance;
    }

    void someMethod() {
        std::lock_guard<std::mutex> lock(mutex);
        std::cout << "Method of the singleton called\n";
        std::cout << std::hex << this << std::dec << std::endl; 
    }

    // 禁止拷贝和赋值
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
};

std::unique_ptr<Singleton> Singleton::instance;
std::once_flag Singleton::initInstanceFlag;
std::mutex Singleton::mutex;

void threadFunction() {
    Singleton& s = Singleton::getInstance();
    s.someMethod();
}

int main() {
    std::thread t1(threadFunction);
    std::thread t2(threadFunction);
    std::thread t3(threadFunction);

    t1.join();
    t2.join();
    t3.join();

    return 0;
}

在这个例子中， std::once_flag 确保 Singleton 的实例只被创建一次（即使多个线程同时调用 getInstance()，构造函数也只会被调用一次），可以看出这种实现是线程安全的。

优点

简化代码：相比使用互斥锁，std::once_flag 使得一次性初始化的代码更加简洁。
性能优化：在已初始化的情况下，std::call_once 的开销很小。
避免竞态条件：有效防止了在初始化过程中可能出现的竞态条件。

注意事项

异常处理：如果在 call_once 调用的函数中抛出异常，once_flag 会被重置，允许再次尝试初始化。
不可重入：一旦初始化完成，后续的 call_once 调用将不会执行关联的函数。
生命周期管理：确保 once_flag 的生命周期覆盖所有可能的 call_once 调用。

C++17中`std::call_once`的改进

C++17 引入了 std::call_once 的变体，允许传递参数给被调用的函数，这里模仿多线程情况下，安全进行数据库连接。

#include <iostream>
#include <mutex>
#include <string>
#include <thread>
#include <vector>

class DatabaseConnection {
public:
    static DatabaseConnection& getInstance() {
        static DatabaseConnection instance;
        return instance;
    }

    void initialize(const std::string& host, int port, const std::string& username, const std::string& password) {
        std::call_once(init_flag, &DatabaseConnection::init, this, host, port, username, password);
    }

    void query(const std::string& sql) {
        std::cout << "Executing query: " << sql << " on " << m_host << ":" << m_port << std::endl;
    }

private:
    DatabaseConnection() = default;
    ~DatabaseConnection() = default;
    DatabaseConnection(const DatabaseConnection&) = delete;
    DatabaseConnection& operator=(const DatabaseConnection&) = delete;

    void init(const std::string& host, int port, const std::string& username, const std::string& password) {
        // 模拟数据库连接初始化
        std::cout << "Initializing database connection to " << host << ":" << port 
                  << " with username " << username << std::endl;
        m_host = host;
        m_port = port;
        m_username = username;
        m_password = password;
        std::cout << "Database connection initialized." << std::endl;
    }

    std::once_flag init_flag;
    std::string m_host;
    int m_port;
    std::string m_username;
    std::string m_password;
};

void worker(int id) {
    std::cout << "Worker " << id << " starting..." << std::endl;
    DatabaseConnection::getInstance().initialize("localhost", 5432, "user", "password");
    DatabaseConnection::getInstance().query("SELECT * FROM users");
}

int main() {
    std::vector<std::thread> threads;
    for (int i = 0; i < 5; ++i) {
        threads.emplace_back(worker, i);
    }

    for (auto& t : threads) {
        t.join();
    }

    return 0;
}

运行这个程序，就会看到：

（1）数据库连接只被初始化一次，尽管有多个线程调用 initialize 方法。

（2）所有线程都能够使用相同的初始化后的数据库连接。

可以看到 std::call_once 支持参数传递，并实现线程安全的一次性初始化。这种方法特别适用于需要复杂设置（配置）的单例对象，确保在多线程环境中也能安全、高效地进行初始化。

总结

std::once_flag 是一个强大而简洁的同步工具，特别适用于需要线程安全的一次性初始化场景。它提供了一种简单、高效、且线程安全的方式来确保某段代码只执行一次，这在多线程编程中是一个非常有用的特性。

正文内容已启用复制保护，代码块与行内代码仍支持复制。

评论区

欢迎参与讨论，评论提交与展示状态会在下方同步更新。

当前站点暂未开放评论提交功能。

读者留言

还没有评论，来发表第一条评论吧。

共 0 条评论已展示 0 / 0 条评论

当前还没有评论，来发表第一条评论吧。若评论需要审核，通过后会展示在这里。

侧边栏

包含文章信息、标签与快速入口。

收起展开侧栏

文章目录

自动生成，可快速定位到对应段落。

5.3k

文章信息

文章别名 c-学习-十三

分类学习记录

标签数量 1

评论数量 0

C++学习（十三）

正文内容

C++ 多线程库 <thread>

C++ <thread> 库概述

创建线程

启动线程

等待线程完成

销毁线程

实例：使用 <thread> 创建并行计算

注意事项

类和函数

主要组件

std::thread

std::mutex

std::lock_guard

std::unique_lock

std::condition_variable

stdfuture 和 stdpromise

std::async

C++ 标准库 <mutex>

基本语法

实例

1. 使用 std::mutex

2. 使用 std::recursive_mutex

注意事项

更多说明

1. std::mutex

2. std::recursive_mutex

3. std::timed_mutex

4. std::recursive_timed_mutex

5. std::lock_guard

6. std::unique_lock

7. std::adopt_lock_t

8. std::defer_lock_t

9. std::try_to_lock_t

10. std::shared_mutex

关于std::once_flag

基本概念

示例：单例模式实现

优点

注意事项

C++17中std::call_once的改进

总结

评论区

读者留言

C++ 多线程库 `<thread>`

C++ `<thread>` 库概述

实例：使用 `<thread>` 创建并行计算

C++ 标准库 `<mutex>`

1. 使用 `std::mutex`

2. 使用 `std::recursive_mutex`

C++17中`std::call_once`的改进