C++标准库中的多线程支持是从C++11开始引入的。下面是您提到的几个类的基本用法：

std::thread

std::thread用于创建一个新的线程。

#include <iostream>
#include <thread>

void function() {
    std::cout << "Thread function\n";
}

int main() {
    std::thread t(function); // 创建一个线程，执行function
    t.join(); // 等待线程结束
    return 0;
}

std::mutex

std::mutex用于同步线程，防止多个线程同时访问共享数据。

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

std::mutex mtx; // 创建互斥锁

void print_block(int n, char c) {
    mtx.lock(); // 上锁
    for (int i = 0; i < n; ++i) { std::cout << c; }
    std::cout << '\n';
    mtx.unlock(); // 解锁
}

int main() {
    std::thread t1(print_block, 50, '*');
    std::thread t2(print_block, 50, '#39;);

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

    return 0;
}

std::lock_guard

std::lock_guard是一个互斥包装器，它提供了一个方便的RAII（资源获取即初始化）风格的机制，用于在某个作用域内持有互斥锁。

void print_block(int n, char c) {
    std::lock_guard<std::mutex> lock(mtx); // 上锁，作用域结束时自动解锁
    for (int i = 0; i < n; ++i) { std::cout << c; }
    std::cout << '\n';
}

std::unique_lock

std::unique_lock是一个更灵活的互斥包装器，它允许延迟锁定、尝试锁定、时间锁定以及在作用域内手动解锁和重新锁定。

void print_block(int n, char c) {
    std::unique_lock<std::mutex> lock(mtx, std::defer_lock); // 创建未锁定的互斥锁
    // ... 在这里可以做一些不需要锁的操作 ...
    lock.lock(); // 手动上锁
    for (int i = 0; i < n; ++i) { std::cout << c; }
    std::cout << '\n';
    // lock在作用域结束时自动解锁
}

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);
    while (!ready) { cv.wait(lock); } // 等待直到ready为true
    std::cout << "thread " << id << '\n';
}

void go() {
    std::unique_lock<std::mutex> lock(mtx);
    ready = true;
    cv.notify_all(); // 唤醒所有等待的线程
}

int main() {
    std::thread threads[10];
    for (int i = 0; i < 10; ++i)
        threads[i] = std::thread(print_id, i);

    std::cout << "10 threads ready to race...\n";
    go(); // 准备赛跑

    for (auto& th : threads) th.join();

    return 0;
}

在使用多线程时，需要特别注意数据竞争和死锁等问题，确保线程安全。