c++ std::thread

std::thread 是 C++11 标准库中引入的一个多线程编程工具，它允许开发者在程序中创建和管理线程。通过 std::thread，开发者可以轻松地将任务分配到多个线程中并行执行，从而提高程序的性能和响应速度。本文将详细介绍 std::thread 的基本用法、线程管理、线程同步以及一些常见的使用场景。

1. std::thread 的基本用法

std::thread 的构造函数接受一个可调用对象（如函数、Lambda 表达式、函数对象等）作为参数，并创建一个新的线程来执行该可调用对象。以下是一个简单的示例：

#include <iostream>
#include <thread>

void hello() {
    std::cout << "Hello from thread!" << std::endl;
}

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

在这个示例中，std::thread t(hello) 创建了一个新线程 t，该线程执行 hello 函数。t.join() 用于等待线程 t 执行完毕，确保主线程在子线程完成后再继续执行。

2. 线程的创建与销毁

std::thread 的构造函数可以接受多种类型的可调用对象。除了普通函数外，还可以使用 Lambda 表达式、函数对象等。例如：

#include <iostream>
#include <thread>

int main() {
    std::thread t([]() {
        std::cout << "Hello from Lambda!" << std::endl;
    });
    t.join();
    return 0;
}

在这个示例中，我们使用 Lambda 表达式作为线程的执行函数。

需要注意的是，std::thread 对象在销毁时会自动调用 std::terminate，除非线程已经被 join() 或 detach()。join() 会阻塞当前线程，直到被调用的线程执行完毕；而 detach() 会将线程与 std::thread 对象分离，使其在后台独立运行。例如：

#include <iostream>
#include <thread>

void background_task() {
    std::cout << "Running in the background..." << std::endl;
}

int main() {
    std::thread t(background_task);
    t.detach();  // 将线程分离，使其在后台运行
    std::cout << "Main thread continues..." << std::endl;
    return 0;
}

在这个示例中，t.detach() 将线程 t 与主线程分离，使其在后台运行。主线程不会等待 background_task 执行完毕，而是继续执行。

3. 线程的同步与互斥

在多线程编程中，多个线程可能会同时访问共享资源，这会导致数据竞争（Data Race）问题。为了避免数据竞争，C++ 提供了多种同步机制，如互斥量（Mutex）、条件变量（Condition Variable）等。

3.1 互斥量（Mutex）

std::mutex 是 C++ 标准库中提供的一个互斥量类，用于保护共享资源。通过 std::mutex，可以确保同一时间只有一个线程访问共享资源。以下是一个使用 std::mutex 的示例：

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

std::mutex mtx;

void print_thread_id(int id) {
    mtx.lock();  // 加锁
    std::cout << "Thread ID: " << id << std::endl;
    mtx.unlock();  // 解锁
}

int main() {
    std::thread t1(print_thread_id, 1);
    std::thread t2(print_thread_id, 2);
    t1.join();
    t2.join();
    return 0;
}

在这个示例中，mtx.lock() 和 mtx.unlock() 用于保护 std::cout，确保同一时间只有一个线程可以访问它。

为了简化互斥量的使用，C++11 还引入了 std::lock_guard，它可以在构造时自动加锁，在析构时自动解锁。例如：

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

std::mutex mtx;

void print_thread_id(int id) {
    std::lock_guard<std::mutex> lock(mtx);  // 自动加锁和解锁
    std::cout << "Thread ID: " << id << std::endl;
}

int main() {
    std::thread t1(print_thread_id, 1);
    std::thread t2(print_thread_id, 2);
    t1.join();
    t2.join();
    return 0;
}

在这个示例中，std::lock_guard 对象 lock 在构造时自动加锁，在析构时自动解锁，从而避免了手动调用 mtx.lock() 和 mtx.unlock() 的麻烦。

3.2 条件变量（Condition Variable）

std::condition_variable 是 C++ 标准库中提供的一个条件变量类，用于线程间的同步。条件变量通常与互斥量一起使用，用于等待某个条件成立。以下是一个使用 std::condition_variable 的示例：

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

std::mutex mtx;
std::condition_variable cv;
bool ready = false;

void print_thread_id(int id) {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, []() { return ready; });  // 等待条件成立
    std::cout << "Thread ID: " << id << std::endl;
}

int main() {
    std::thread t1(print_thread_id, 1);
    std::thread t2(print_thread_id, 2);

    std::this_thread::sleep_for(std::chrono::seconds(1));  // 模拟耗时操作
    {
        std::lock_guard<std::mutex> lock(mtx);
        ready = true;  // 设置条件为真
    }
    cv.notify_all();  // 通知所有等待的线程

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

在这个示例中，cv.wait(lock, []() { return ready; }) 用于等待 ready 变为 true。当 ready 变为 true 时，cv.notify_all() 会通知所有等待的线程继续执行。

4. 线程的返回值与异常处理

std::thread 本身并不直接支持返回值，但可以通过 std::future 和 std::promise 来实现线程的返回值传递。以下是一个使用 std::future 和 std::promise 的示例：

#include <iostream>
#include <thread>
#include <future>

int compute() {
    return 42;
}

int main() {
    std::promise<int> p;
    std::future<int> f = p.get_future();

    std::thread t([&p]() {
        p.set_value(compute());
    });

    std::cout << "Result: " << f.get() << std::endl;  // 获取线程的返回值
    t.join();
    return 0;
}

在这个示例中，std::promise 对象 p 用于存储线程的返回值，std::future 对象 f 用于获取线程的返回值。

对于异常处理，如果在线程中抛出异常，且未被捕获，则程序会调用 std::terminate。为了避免这种情况，可以在线程中捕获异常并将其传递给主线程。例如：

#include <iostream>
#include <thread>
#include <future>

void may_throw() {
    throw std::runtime_error("Error in thread!");
}

int main() {
    std::promise<void> p;
    std::future<void> f = p.get_future();

    std::thread t([&p]() {
        try {
            may_throw();
            p.set_value();
        } catch (...) {
            p.set_exception(std::current_exception());
        }
    });

    try {
        f.get();
    } catch (const std::exception& e) {
        std::cout << "Caught exception: " << e.what() << std::endl;
    }

    t.join();
    return 0;
}

在这个示例中，p.set_exception(std::current_exception()) 用于将线程中的异常传递给主线程。

5. 线程的常见使用场景

std::thread 在实际开发中有许多常见的应用场景，例如：

• 并行计算：将计算任务分配到多个线程中并行执行，以提高计算效率。
• 异步 I/O：使用线程来处理耗时的 I/O 操作，以避免阻塞主线程。
• 事件驱动编程：使用线程来处理事件循环，以提高程序的响应速度。
• 生产者-消费者模型：使用线程来实现生产者-消费者模型，以处理数据流。

6. 总结

std::thread 是 C++11 标准库中提供的一个强大的多线程编程工具，它允许开发者轻松地创建和管理线程。通过 std::thread，开发者可以实现并行计算、异步 I/O、事件驱动编程等多种多线程应用场景。然而，多线程编程也带来了数据竞争、死锁等问题，因此在使用 std::thread 时，开发者需要仔细设计线程间的同步与互斥机制，以确保程序的正确性和稳定性。

在本文中，我们详细介绍了 std::thread 的基本用法、线程管理、线程同步以及一些常见的使用场景。希望通过这些内容，读者能够更好地理解和使用 std::thread，从而编写出高效、稳定的多线程程序。