C++ 创建线程与安全结束线程

创建线程并安全结束线程的模板

#include <iostream>
#include <pthread.h>
#include <unistd.h>

// 线程函数
void* thread_function(void* arg) {
    bool* run = static_cast<bool*>(arg); // 将参数转换为布尔指针
    int count = 0;

    while (*run) { // 检查标志变量
        std::cout << "Thread is running... Count: " << count++ << std::endl;
        sleep(1); // 模拟工作负载
    }

    std::cout << "Thread is exiting..." << std::endl;
    return nullptr; // 线程正常退出
}

int main() {
    pthread_t thread_id; // 线程ID
    bool run = true;     // 标志变量，控制线程运行状态

    // 创建线程
    if (pthread_create(&thread_id, nullptr, thread_function, &run) != 0) {
        std::cerr << "Failed to create thread" << std::endl;
        return -1;
    }

    // 主线程运行一段时间
    std::cout << "Main thread is running..." << std::endl;
    sleep(5);

    // 设置标志变量为false，通知线程退出
    run = false;

    // 等待线程结束
    if (pthread_join(thread_id, nullptr) != 0) {
        std::cerr << "Failed to join thread" << std::endl;
        return -1;
    }

    std::cout << "Thread has been safely stopped and joined." << std::endl;

    return 0;
}

使用 std::lock_guard\<std::mutex> 的线程间数据交换模板

#include <iostream>
#include <pthread.h>
#include <mutex>
#include <unistd.h>

// 共享数据结构
struct SharedData {
    int value; // 共享数据
    bool updated; // 标志变量，表示数据是否已更新
    std::mutex data_mutex_; // 互斥锁
    bool run; // 控制线程运行状态
};

// 线程函数
void* thread_function(void* arg) {
    SharedData* shared_data = static_cast<SharedData*>(arg);

    while (true) {
        // 模拟工作负载
        sleep(1);

        // 更新共享数据
        {
            std::lock_guard<std::mutex> lock(shared_data->data_mutex_); // 自动加锁
            shared_data->value += 10; // 更新数据
            shared_data->updated = true; // 设置更新标志
            std::cout << "Thread updated value to: " << shared_data->value << std::endl;
        } // 作用域结束，自动解锁

        // 检查是否需要退出
        {
            std::lock_guard<std::mutex> lock(shared_data->data_mutex_);
            if (!shared_data->run) {
                break;
            }
        }
    }

    std::cout << "Thread is exiting..." << std::endl;
    return nullptr;
}

int main() {
    pthread_t thread_id; // 线程ID
    SharedData shared_data = {0, false, {}, true}; // 初始化共享数据

    // 创建线程
    if (pthread_create(&thread_id, nullptr, thread_function, &shared_data) != 0) {
        std::cerr << "Failed to create thread" << std::endl;
        return -1;
    }

    // 主线程运行一段时间
    std::cout << "Main thread is running..." << std::endl;
    for (int i = 0; i < 5; ++i) {
        sleep(1); // 模拟工作负载

        // 检查共享数据是否更新
        {
            std::lock_guard<std::mutex> lock(shared_data.data_mutex_);
            if (shared_data.updated) {
                std::cout << "Main thread received value: " << shared_data.value << std::endl;
                shared_data.updated = false; // 清除更新标志
            }
        }
    }

    // 设置标志变量为false，通知线程退出
    {
        std::lock_guard<std::mutex> lock(shared_data.data_mutex_);
        shared_data.run = false;
    }

    // 等待线程结束
    if (pthread_join(thread_id, nullptr) != 0) {
        std::cerr << "Failed to join thread" << std::endl;
        return -1;
    }

    std::cout << "Thread has been safely stopped and joined." << std::endl;

    return 0;
}