当前位置：首页 > article >正文

线程创建与管理 - 创建线程、线程同步（C++）

article 2025/2/5 17:21:11

前言

在现代软件开发中，线程的创建和管理是并发编程的核心内容之一。通过合理地创建和管理线程，可以有效提高程序的响应速度和资源利用率。本文将详细讲解如何在C++中创建线程，并探讨几种常见的线程同步机制。我们假设读者具备一定的C++基础，但对多线程编程较为陌生。希望通过本文的学习，能够让读者掌握线程的基本操作方法及其同步技巧。

1. 创建线程

自C++11起，标准库引入了对多线程的支持，开发者可以借助<thread>头文件中的std::thread类来轻松实现线程的创建与管理。接下来我们将介绍几种常用的创建线程的方式。

1.1 直接传递函数名

这是最简单直接的方式，只需指定要在线程中执行的目标函数即可：

#include <iostream>
#include <thread>

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

int main() {
    // 创建一个新的线程来执行print_hello函数
    std::thread t(print_hello);

    // 等待线程结束
    if (t.joinable()) {
        t.join();
    }

    return 0;
}

1.2 传递带参数的函数

如果需要给线程传递参数，则可以在构造std::thread对象时一并提供这些参数：

void print_message(const std::string& message) {
    std::cout << message << std::endl;
}

int main() {
    std::string msg = "Hello from a thread!";
    std::thread t(print_message, msg);

    if (t.joinable()) {
        t.join();
    }

    return 0;
}

1.3 使用Lambda表达式

除了直接传递函数指针外，还可以利用C++11提供的lambda表达式来定义更为灵活的任务逻辑：

int main() {
    int value = 42;
    std::thread t([value]() {
        std::cout << "Value is: " << value << std::endl;
    });

    if (t.joinable()) {
        t.join();
    }

    return 0;
}

2. 线程同步

当多个线程共同访问某些共享资源时，如果不加以控制可能会导致不可预测的结果，这就是所谓的“竞争条件”或“数据竞争”。为了避免这种情况的发生，必须采取有效的同步措施。以下是几种常见的同步方式。

2.1 互斥量（Mutex）

互斥量是最基本也是最常用的一种同步工具，它可以确保同一时刻只有一个线程能够访问被保护的数据。使用时，通常会结合std::lock_guard来自动管理锁的获取和释放，从而简化代码逻辑并减少错误发生的可能性。

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

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

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';
}

int main() {
    std::thread th1(print_block, 50, '*');
    std::thread th2(print_block, 50, '$');

    th1.join();
    th2.join();

    return 0;
}

2.2 条件变量（Condition Variable）

条件变量允许一个或多个线程等待某个特定事件的发生，而其他线程则负责通知它们继续执行。这在生产者-消费者模式等场景下非常有用。下面是一个简单的例子，展示了如何使用条件变量来进行线程间的通信：

#include <iostream>
#include <thread>
#include <condition_variable>
#include <queue>
#include <functional>
#include <chrono>

std::condition_variable cv;
std::mutex cv_m;
std::queue<int> data_queue;

void consumer() {
    while (true) {
        std::unique_lock<std::mutex> lck(cv_m);
        cv.wait(lck, [] { return !data_queue.empty(); }); // 等待队列非空
        int data = data_queue.front();
        data_queue.pop();
        lck.unlock();

        std::cout << "Consumed: " << data << '\n';

        if (data == -1) break; // 结束条件
    }
}

void producer() {
    for (int i = 0; i <= 5; ++i) {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        std::lock_guard<std::mutex> lck(cv_m);
        data_queue.push(i);
        cv.notify_one(); // 通知一个等待中的线程
    }

    // 发送结束信号
    std::lock_guard<std::mutex> lck(cv_m);
    data_queue.push(-1);
    cv.notify_one();
}

int main() {
    std::thread c(consumer);
    std::thread p(producer);

    p.join();
    c.join();

    return 0;
}