哪些 C++ 函数库函数是多线程安全的？

#include <iostream>
#include <atomic>

// 定义一个原子整数 counter
std::atomic<int> counter(0);

// 线程函数，递增计数器
void incrementCounter() {
    counter++;
}

int main() {
    // 创建 10 个线程
    std::thread threads[10];

    // 启动线程来递增计数器
    for (int i = 0; i < 10; i++) {
        threads[i] = std::thread(incrementCounter);
    }

    // 加入线程
    for (int i = 0; i < 10; i++) {
        threads[i].join();
    }

    // 打印最终计数
    std::cout << "最终计数：" << counter << std::endl;

    return 0;
}

#include <iostream>
#include <mutex>

std::mutex m; // 定义一个互斥量

void accessSharedResource() {
    // 获取互斥量
    m.lock();

    // 访问共享资源

    // 释放互斥量
    m.unlock();
}

int main() {
    // 为 10 个线程创建互斥量
    std::thread threads[10];

    // 启动线程
    for (int i = 0; i < 10; i++) {
        threads[i] = std::thread(accessSharedResource);
    }

    // 加入线程
    for (int i = 0; i < 10; i++) {
        threads[i].join();
    }

    return 0;
}

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

std::mutex m; // 定义一个互斥量
std::condition_variable cv; // 定义条件变量
bool ready = false; // 布尔标志表示生产者是否已生产

void producer() {
    // 获取互斥量
    m.lock();

    // 生产数据
    std::cout << "生产者生产数据" << std::endl;
    ready = true;

    // 唤醒消费者线程
    cv.notify_one();

    // 释放互斥量
    m.unlock();
}

void consumer() {
    // 获取互斥量
    m.lock();

    // 等待生产者生产数据
    while (!ready) {
        cv.wait(m);
    }

    // 消费数据
    std::cout << "消费者消费数据" << std::endl;
    ready = false;

    // 释放互斥量
    m.unlock();
}

int main() {
    // 为生产者和消费者线程创建互斥量、条件变量和布尔标志
    std::thread producerThread(producer);
    std::thread consumerThread(consumer);

    // 加入线程
    producerThread.join();
    consumerThread.join();

    return 0;
}