C++并发支持库¶

// 简单例子
std::thread t;

#include <iostream>
#include <thread>

void test()
{
    std::cout << "test" << std::endl;
}

// 注释
int main()
{
    // 创建空的线程
    std::thread t;

    // 后续需要使用上面的线程需要单独再创建一个线程
    std::thread t1(test);
    t = std::move(t1);
    // 不能单独复制一个非右值对象
    // t = t1;

    t.join();

    return 0;
}

// 简单例子
void foo(int x) 
{ 
    std::cout << x << std::endl; 
}
std::thread t(foo, 42);

#include <iostream>
#include <thread>

void test1(int &x)
{
    std::cout << "修改前：x为 " << x << std::endl;
    ++x;
    std::cout << "修改后：x为 " << x << std::endl;
}

// 注释
int main()
{
    int x = 1;

    std::thread t(test1, x);

    t.join();

    return 0;
}

// 输出
修改前：x为 1
修改后：x为 2

std::thread t1(foo, 42);
std::thread t2 = t1; // 编译错误

std::thread t1(foo, 42);
std::thread t2(t1); // t1的所有权转移给t2

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

void worker(int n) 
{
    std::cout << "线程 " << std::this_thread::get_id() << " 开始工作，参数: " << n << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(n));
    std::cout << "线程 " << std::this_thread::get_id() << " 工作完成" << std::endl;
}

int main() 
{
    // 默认构造函数创建空线程
    std::thread t1;
    std::cout << "t1 ID: " << t1.get_id() << std::endl;
    std::cout << "t1 是否可join: " << std::boolalpha << t1.joinable() << std::endl;

    // 创建实际工作的线程
    std::thread t2(worker, 2);
    std::cout << "t2 ID: " << t2.get_id() << std::endl;
    // std::boolalpha 是一个格式化标志，用于将布尔值输出为 "true" 或 "false"
    std::cout << "t2 是否可join: " << t2.joinable() << std::endl;

    // 创建另一个工作线程
    std::thread t3(worker, 3);

    // 使用swap交换两个线程
    std::cout << "交换前 - t2 ID: " << t2.get_id() << ", t3 ID: " << t3.get_id() << std::endl;
    t2.swap(t3);
    std::cout << "交换后 - t2 ID: " << t2.get_id() << ", t3 ID: " << t3.get_id() << std::endl;

    // 使用join等待线程完成
    if (t2.joinable()) 
    {
        std::cout << "等待t2完成..." << std::endl;
        t2.join();
        std::cout << "t2已完成" << std::endl;
    }

    // 使用detach分离线程
    if (t3.joinable()) 
    {
        std::cout << "分离t3..." << std::endl;
        t3.detach();
        std::cout << "t3已分离，t3是否可join: " << t3.joinable() << std::endl;
    }

    return 0;
}

std::thread t([] {});
if (t.joinable()) {
    t.join(); // 或者 t.detach();
}

#include <iostream>
#include <thread>
#include <chrono>
#include <iomanip> // 用于格式化输出时间

void print_time(const std::string& message) 
{
    auto now = std::chrono::system_clock::now();
    auto now_c = std::chrono::system_clock::to_time_t(now);
    std::cout << message << " - 时间: " 
              << std::put_time(std::localtime(&now_c), "%H:%M:%S") << std::endl;
}

int main() 
{
    // 1. 获取当前线程ID
    std::cout << "当前线程ID: " << std::this_thread::get_id() << std::endl;

    // 2. 使用yield让出时间片
    std::cout << "准备让出时间片..." << std::endl;
    std::this_thread::yield();
    std::cout << "继续执行..." << std::endl;

    // 3. 使用sleep_for暂停指定时间
    print_time("准备休眠2秒");
    std::this_thread::sleep_for(std::chrono::seconds(2));
    print_time("休眠结束");

    // 4. 使用sleep_until暂停到指定时间点
    auto now = std::chrono::system_clock::now();
    auto wake_time = now + std::chrono::seconds(3);

    print_time("准备休眠到指定时间点(当前时间+3秒)");
    std::this_thread::sleep_until(wake_time);
    print_time("到达指定时间点，继续执行");

    return 0;
}

#include <mutex>

// 定义一个递归函数
void recursion(int n, std::mutex& mtx, int &x)
{
    // 加锁保护临界区资源
    mtx.lock();
    if (n == 0)
    {
        mtx.unlock();
        return;
    }
    for (int i = 0; i < n; i++)
        ++x;
    recursion(n - 10, mtx, x);
    mtx.unlock();
}

int main()
{
    int n = 100;
    int x = 0;
    std::mutex mtx;
    // 注意使用引用传递
    std::thread t(recursion, n, std::ref(mtx), std::ref(x));

    t.join();
    return 0;
}

// 定义一个递归函数
void recursion(int n, std::recursive_mutex& mtx, int &x)
{
    // 加锁保护临界区资源
    mtx.lock();
    if (n == 0)
    {
        mtx.unlock(); // 确保在返回前解锁
        return;
    }
    for (int i = 0; i < n; i++)
        ++x;
    recursion(n - 10, mtx, x);
    mtx.unlock();
}

int main()
{
    int n = 100;
    int x = 0;
    // 使用递归锁
    std::recursive_mutex mtx;
    // 注意使用引用传递
    std::thread t(recursion, n, std::ref(mtx), std::ref(x));

    t.join();
    return 0;
}

void test(int n, std::timed_mutex &tmtx, int &x)
{
    // 不要直接使用lock
    // tmtx.lock();
    // 使用try_lock_for
    while (tmtx.try_lock_for(std::chrono::milliseconds(1000));)
    {
        for (int i = 0; i < n; i++)
            ++x;
    }

    tmtx.unlock();
}

int main()
{
    std::timed_mutex tmtx;
    int x = 1;
    int n = 100;

    std::thread t(test, n, std::ref(tmtx), std::ref(x));

    std::thread t1(test, n, std::ref(tmtx), std::ref(x));

    t.join();
    t1.join();

    return 0;
}

std::mutex mtx;
// 1. defer_lock_t 示例：延迟加锁
void defer_lock_example(int id)
{
    // 创建锁但不立即加锁
    std::unique_lock<std::mutex> lock(mtx, std::defer_lock);

    // 执行一些不需要锁的操作
    std::cout << "线程 " << id << " 正在执行不需要锁的操作..." << std::endl;
    std::this_thread::sleep_for(std::chrono::milliseconds(200));

    // 在需要的时候手动加锁
    std::cout << "线程 " << id << " 尝试获取锁..." << std::endl;
    lock.lock();
    std::cout << "线程 " << id << " 获取到了锁" << std::endl;

    // 执行需要锁保护的操作
    std::this_thread::sleep_for(std::chrono::milliseconds(500));

    // 可以手动解锁
    lock.unlock();
    std::cout << "线程 " << id << " 手动释放了锁" << std::endl;

    // 执行更多不需要锁的操作
    std::this_thread::sleep_for(std::chrono::milliseconds(200));

    // 可以再次加锁
    lock.lock();
    std::cout << "线程 " << id << " 再次获取到了锁" << std::endl;
    std::this_thread::sleep_for(std::chrono::milliseconds(300));

    // 锁会在unique_lock析构时自动释放
}

// 2. adopt_lock_t 示例：接管已加锁的互斥量
void adopt_lock_example(int id)
{
    // 先手动加锁
    mtx.lock();
    std::cout << "线程 " << id << " 手动获取了锁" << std::endl;

    // 创建unique_lock并接管已加锁的互斥量
    {
        std::unique_lock<std::mutex> lock(mtx, std::adopt_lock);
        std::cout << "线程 " << id << " 的unique_lock接管了锁的所有权" << std::endl;

        // 执行需要锁保护的操作
        std::this_thread::sleep_for(std::chrono::milliseconds(800));

        std::cout << "线程 " << id << " 即将退出作用域，锁将被自动释放" << std::endl;
        // 锁会在unique_lock析构时自动释放
    }

    // 此时锁已被释放，可以执行其他操作
    std::cout << "线程 " << id << " 的锁已被释放" << std::endl;
}

int main()
{
    std::cout << "\n=== defer_lock 示例 ===" << std::endl;
    {
        std::thread t(defer_lock_example, 1);
        t.join();
    }

    std::cout << "\n=== adopt_lock 示例 ===" << std::endl;
    {
        std::thread t(adopt_lock_example, 1);
        t.join();
    }

    return 0;
}

std::mutex mtx;

void try_lock_example(int id)
{
    // 尝试获取锁，如果失败则不阻塞
    std::unique_lock<std::mutex> lock(mtx, std::try_to_lock);

    if (lock.owns_lock()) // 可以直接使用if(lock)，调用operator bool
    {
        // 成功获取到锁
        std::cout << "线程 " << id << " 获取到了锁" << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
        std::cout << "线程 " << id << " 完成工作并释放锁" << std::endl;
    }
    else 
    {
        // 未能获取到锁
        std::cout << "线程 " << id << " 未能获取锁，执行替代操作" << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(500));
    }
    // 锁会在unique_lock析构时自动释放（如果已获取）
}

int main()
{
    std::cout << "=== try_to_lock 示例 ===" << std::endl;
    {
        // 创建两个线程同时尝试获取锁
        std::thread t1(try_lock_example, 1);
        std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 确保t1先运行
        std::thread t2(try_lock_example, 2);

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

    return 0;
}

std::mutex mtx1;
std::mutex mtx2;

void test1()
{
    std::unique_lock<std::mutex> lock1(mtx1, std::defer_lock);
    lock1.lock();
    // 当前线程休眠1s确保test2先获取到mtx2
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::unique_lock<std::mutex> lock2(mtx2, std::defer_lock);
    lock2.lock();

    for (int i = 0; i < 10; i++)
        std::cout << std::this_thread::get_id() << "正在执行" << std::endl;

    lock2.unlock();
    lock1.unlock();
}

void test2()
{
    std::unique_lock<std::mutex> lock2(mtx2, std::defer_lock);
    lock2.lock();
    std::unique_lock<std::mutex> lock1(mtx1, std::defer_lock);
    lock1.lock();

    for (int i = 0; i < 10; i++)
        std::cout << std::this_thread::get_id() << "正在执行" << std::endl;

    lock1.unlock();
    lock2.unlock();
}

int main()
{
    std::thread t1(test1);
    std::thread t2(test2);

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

    return 0;
}

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

// 声明一个once_flag变量作为是否是第一次调用的标志
std::once_flag flag;

void initialize()
{
    std::cout << std::this_thread::get_id() << "Initializing..." << std::endl;
}

void thread_func() 
{
    // 确保 initialize 函数只被调用一次
    std::call_once(flag, initialize);
}

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

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

    return 0;
}

std::is_trivially_copyable<T>::value
std::is_copy_constructible<T>::value
std::is_move_constructible<T>::value
std::is_copy_assignable<T>::value
std::is_move_assignable<T>::value
std::is_same<T, typename std::remove_cv<T>::type>::value

#include <string>

struct Date
{
    int _year = 1;
    int _month = 1;
    int _day = 1;
};

template<class T>
void check()
{
    std::cout << typeid(T).name() << std::endl;
    std::cout << std::boolalpha << std::is_trivially_copyable<T>::value << std::endl; 
    std::cout << std::boolalpha << std::is_copy_constructible<T>::value << std::endl; 
    std::cout << std::boolalpha << std::is_move_constructible<T>::value << std::endl; 
    std::cout << std::boolalpha << std::is_copy_assignable<T>::value << std::endl; 
    std::cout << std::boolalpha << std::is_move_assignable<T>::value << std::endl; 
    std::cout << std::boolalpha << std::is_same<T, typename std::remove_cv<T>::type>::value << std::endl << std::endl;
}

int main()
{
    check<int>();
    check<double>();
    check<int*>();
    check<Date>();
    check<Date*>();
    check<std::string>();
    check<std::string*>();

    return 0;
}

#include <atomic>
#include <vector>

struct Node 
{ 
    int value; 
    Node* next; 
};

std::atomic<Node*> list_head(nullptr);

void insertBefore(int val) 
{     
    // 相当于Node* oldHead = list_head; 这里用到了operator T()函数，将atomic对象转换为存储的内容
    Node* oldHead = list_head.load();
    Node* newNode = new Node{ val,oldHead };

    while (!list_head.compare_exchange_weak(oldHead, newNode))
        newNode->next = oldHead;
}

int main()
{
    std::vector<std::thread> threads;

    for (int i = 0; i < 10; ++i) 
        threads.push_back(std::thread(insertBefore, i));
    for (auto& th : threads) 
        th.join();

    for (Node* it = list_head; it != nullptr; it = it->next)
        std::cout << ' ' << it->value;
    std::cout << '\n';

    Node* it; 
    while (it = list_head) 
    { 
        list_head = it->next; 
        delete it; 
    }

    return 0;
}

bool compare_exchange_weak(T& expected, T desired,
                          memory_order success,
                          memory_order failure);

#include <atomic>
#include <thread>
#include <iostream>

std::atomic<bool> ready(false);
std::atomic<int> data(0);

void producer() 
{
    // 准备数据
    data.store(42, std::memory_order_relaxed);

    // 使用memory_order_release确保之前的写入对其他线程可见
    ready.store(true, std::memory_order_release);
}

void consumer() 
{
    // 等待数据准备好，使用memory_order_acquire确保能看到之前的写入
    while (!ready.load(std::memory_order_acquire)) 
    {
        // 等待，直到读取到ready为true
    }

    // 此处保证能看到producer中对data的写入
    int result = data.load(std::memory_order_relaxed);
    std::cout << "读取到的数据: " << result << std::endl; // 一定输出42
}

int main() 
{
    std::thread t1(producer);
    std::thread t2(consumer);

    t1.join();
    t2.join();
    return 0;
}

std::atomic<int> count(0);
std::atomic<int> ret;

void test()
{
    ret = count.fetch_add(1);
}

int main()
{
    std::thread t(test);
    std::thread t1(test);

    std::this_thread::sleep_for(std::chrono::seconds(3));

    std::cout << count << std::endl; // 2
    std::cout << ret << std::endl; // 1

    t.join();
    t1.join();

    return 0;
}

while(!predicate())
    wait(lock);