C++ std::thread怎么使用

这篇文章主要介绍了C++ std::thread怎么使用的相关知识，内容详细易懂，操作简单快捷，具有一定借鉴价值，相信大家阅读完这篇C++ std::thread怎么使用文章都会有所收获，下面我们一起来看看吧。

C++是一种高级编程语言，被广泛用于开发高性能、大规模、复杂的软件系统。其中一个强大的特性就是多线程编程，而std::thread是C++标准库提供的多线程支持的重要组成部分。

std::thread是一个轻量级线程类，它允许程序员创建、启动、停止、等待线程。与其他多线程库不同，std::thread在运行时不需要显式地创建和销毁线程，而是通过构造和析构线程对象来完成这些操作。

一、std::thread的构造和析构

std::thread的构造函数需要传入一个可调用对象，这个可调用对象可以是一个函数指针、一个函数对象、一个lambda表达式或一个类成员函数指针。创建线程的方式非常简单，例如：

void my_func()
{
    // do something
}

std::thread my_thread(my_func); // 使用函数指针创建线程

线程对象创建后，它的执行路径就已经开始了。我们可以通过std::thread对象的join()方法等待线程结束并阻塞主线程：

std::thread my_thread(my_func);
my_thread.join(); // 阻塞主线程等待子线程结束

当线程对象被销毁时，它会自动调用析构函数，如果线程没有被join()或detach()，则程序会终止并抛出std::terminate异常。

std::thread my_thread(my_func);
// 不调用join()或detach()
// 当my_thread对象离开作用域时会抛出std::terminate异常

二、std::thread的成员函数

std::thread类还有一些非常有用的成员函数，可以帮助我们管理线程的生命周期、获取线程信息和控制线程行为。

1.join()和detach()
join()方法可以阻塞主线程等待子线程结束，而detach()方法则将线程对象与底层线程分离，使得线程对象的生命周期不再受限于线程的生命周期。

std::thread my_thread(my_func);
my_thread.detach(); // 分离线程，线程对象的生命周期不再受限于线程的生命周期

2.get_id()

get_id()方法返回线程对象所代表的线程的唯一标识符，这个标识符可以用来比较不同的线程对象是否代表同一个线程。

std::thread my_thread1(my_func);
std::thread my_thread2(my_func);
if (my_thread1.get_id() == my_thread2.get_id())
{
    // 不会执行到这里
}

3.hardware_concurrency()
hardware_concurrency()方法返回计算机硬件支持的并发线程数，这个值通常等于处理器的核心数。

std::cout << "可用线程数：" << std::thread::hardware_concurrency() << std::endl;

三、线程间的通信

线程间的通信是多线程编程中的一个重要问题，std::thread类提供了一些机制来帮助我们实现线程间的通信和同步。

1.std::atomic
std::atomic是一个原子类型，它可以保证对该类型的操作是原子的，即不会被其他线程中断。std::atomic可以用于实现线程间的共享变量。

std::atomic<int> counter{0};
void my_func()
{
    counter++;
}

int main()
{
    std::thread t1(my_func);
    std::thread t2(my_func);
    t1.join();
    t2.join();
    std::cout << counter << std::endl; // 输出2
    return 0;
}

2.std::mutex和std::lock_guard
std::mutex是一个互斥量，它可以用于实现线程间的互斥访问。std::lock_guard是一个RAII风格的互斥量保护器，它可以在构造函数中获取互斥量的锁，在析构函数中释放互斥量的锁。

std::atomic<int> counter{0};
void my_func()
{
    counter++;
}

int main()
{
    std::thread t1(my_func);
    std::thread t2(my_func);
    t1.join();
    t2.join();
    std::cout << counter << std::endl; // 输出2
    return 0;
}

3.std::condition_variable
std::condition_variable是一个条件变量，它可以用于实现线程间的同步。std::condition_variable通常与std::unique_lock一起使用，可以实现线程的等待和唤醒操作。

std::mutex my_mutex;
std::condition_variable my_cv;
bool ready = false;
void my_func()
{
    std::unique_lock<std::mutex> lock(my_mutex); // 获取互斥量的锁
    ready = true;
    my_cv.notify_one(); // 唤醒等待中的线程
}

int main()
{
    std::thread t1(my_func);
    std::unique_lock<std::mutex> lock(my_mutex);
    my_cv.wait(lock, []{return ready;}); // 等待线程的唤醒
    t1.join();
    return 0;
}

四、线程的异常处理

多线程程序中的异常处理是一个复杂的问题，std::thread类提供了一些机制来帮助我们处理线程中的异常。

1.try-catch块
在线程函数中使用try-catch块可以捕获线程中的异常，防止异常影响其他线程和整个程序。

void my_func()
{
    try
    {
        // do something
    }
    catch (const std::exception& e)
    {
        // 处理异常
    }
}

int main()
{
    std::thread t1(my_func);
    std::thread t2(my_func);
    t1.join();
    t2.join();
    return 0;
}

2.std::terminate
std::terminate是一个函数，它可以用于终止程序的执行。当线程中发生未被捕获的异常时，程序会自动调用std::terminate函数来终止程序的执行。

void my_func()
{
    throw std::runtime_error("something went wrong");
}

int main()
{
    std::thread t1(my_func);
    std::thread t2(my_func);
    t1.join();
    t2.join();
    return 0;
}

在上面的代码中，my_func函数会抛出一个std::runtime_error异常，如果这个异常没有被try-catch块捕获，程序就会调用std::terminate函数来终止程序的执行。

3.std::exception_ptr
std::exception_ptr是一个类，它可以用于保存线程中发生的异常。我们可以在主线程中调用std::exception_ptr::rethrow_exception函数来重新抛出线程中的异常。

std::exception_ptr my_exception;
void my_func()
{
    try
    {
        // do something
    }
    catch (...)
    {
        my_exception = std::current_exception(); // 保存异常
    }
}

int main()
{
    std::thread t1(my_func);
    std::thread t2(my_func);
    t1.join();
    t2.join();
    if (my_exception)
    {
        try
        {
            std::rethrow_exception(my_exception); // 重新抛出异常
        }
        catch (const std::exception& e)
        {
            // 处理异常
        }
    }
    return 0;
}

在上面的代码中，my_func函数会捕获任何类型的异常，并将异常保存到my_exception变量中。在主线程中，如果my_exception变量中保存了异常，我们就调用std::rethrow_exception函数重新抛出异常，并在catch块中处理异常。

关于“C++ std::thread怎么使用”这篇文章的内容就介绍到这里，感谢各位的阅读！相信大家对“C++ std::thread怎么使用”知识都有一定的了解，大家如果还想学习更多知识，欢迎关注亿速云行业资讯频道。