C++ std::thread 使用方法

目录
  • 一、std::thread的构造和析构
  • 二、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++11中的std::thread类是一个强大的多线程编程工具,它可以帮助我们轻松地创建和管理线程。通过std::thread类,我们可以实现线程的创建、启动、停止、等待和同步等操作,并可以使用各种机制来处理线程中的异常和实现线程间的通信。

在使用std::thread类时,我们需要注意以下几点:

  • 线程函数必须是可调用对象,如函数、函数指针、函数对象等。
  • 线程函数的参数必须是可拷贝的,否则需要使用std::ref包装。
  • 线程对象必须在主线程中加入join或detach,否则会导致程序异常。
  • 线程中发生的异常需要进行处理,否则会导致程序崩溃。

线程间的通信需要使用std::atomic、std::mutex、std::lock_guard和std::condition_variable等机制。

std::thread类是一个非常强大的多线程编程工具,它可以帮助我们实现各种复杂的多线程应用。熟练掌握std::thread类的使用方法和机制可以提高我们的多线程编程技能,也可以帮助我们更好地处理线程中的异常和实现线程间的通信。

最后,还有一些需要注意的点:

1.线程安全

多线程编程中一个非常重要的概念就是线程安全。如果多个线程同时访问同一个共享资源,可能会出现数据竞争(data race),导致程序出现不可预期的行为。

为了避免数据竞争,我们需要使用线程同步机制来保护共享资源。常用的线程同步机制包括std::mutex、std::lock_guard、std::unique_lock和std::condition_variable等。这些同步机制可以帮助我们实现互斥锁、条件变量等功能,以确保多个线程之间的正确协同工作。

2.线程池
线程池(thread pool)是一个管理一组线程的对象。线程池可以帮助我们管理线程的数量、复用线程资源、避免线程的创建和销毁等操作,从而提高多线程应用程序的效率。

C++标准库中并没有提供线程池的实现,但是我们可以使用第三方库或自己编写代码来实现线程池。常用的第三方线程池库包括Boost.Thread和Intel TBB等。

3.并发编程模型
并发编程模型是一种抽象的概念,它描述了多个任务之间的交互和协同工作。常用的并发编程模型包括消息传递模型、共享内存模型和数据流模型等。

消息传递模型(message passing)是指多个任务之间通过消息传递来进行通信和同步。共享内存模型(shared memory)是指多个任务之间通过共享内存来进行通信和同步。数据流模型(data flow)是指多个任务之间通过数据流来进行通信和同步。

C++中的std::thread类可以用于实现多个任务之间的并发编程模型。在使用std::thread类时,我们需要考虑线程间的同步和通信问题,以确保多个线程之间的正确协同工作。

4.多线程性能优化
在进行多线程编程时,我们需要考虑多线程性能优化问题。常用的多线程性能优化方法包括:

(1)避免线程的创建和销毁。线程的创建和销毁是比较耗时的操作,如果频繁地创建和销毁线程,会影响多线程应用程序的性能。我们可以使用线程池来复用线程资源,从而避免线程的创建和销毁。

(2)减少锁的使用。锁是一种线程同步机制,但是锁的使用会影响多线程应用程序的性能。如果多个线程之间访问同一个共享资源,可以使用无锁数据结构来避免锁的使用,从而提高多线程应用程序的性能。

(3)避免线程间的频繁通信。线程间的通信是需要开销的,如果频繁地进行线程间的通信,会影响多线程应用程序的性能。我们可以考虑将通信的数据缓存起来,减少线程间的频繁通信。

(4)使用本地变量。在多线程编程中,本地变量的访问不需要锁,可以提高多线程应用程序的性能。如果需要访问共享资源,可以将共享资源拷贝到本地变量中,从而避免锁的使用。

(5)使用任务并行模型。任务并行模型是一种并发编程模型,它可以将一个大任务划分为多个小任务,然后将小任务分配给多个线程来并行执行。这样可以提高多线程应用程序的性能。

总结:

C++中的std::thread类提供了一种方便的多线程编程方式。在使用std::thread类时,我们需要注意线程间的同步和通信问题,以确保多个线程之间的正确协同工作。同时,我们还需要考虑多线程性能优化问题,以提高多线程应用程序的性能。

除了std::thread类,C++标准库还提供了一些其他的多线程编程工具,例如std::async、std::future、std::promise等,它们都可以用于实现多线程编程。在进行多线程编程时,我们需要根据具体的应用场景选择合适的多线程编程工具。

最后,多线程编程是一项非常复杂的任务,需要有一定的经验和技能才能掌握。建议初学者从简单的例子开始,逐步深入了解多线程编程的相关概念和技术。

到此这篇关于C++ std::thread 如何使用?的文章就介绍到这了,更多相关C++ std::thread使用内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • C++11并发编程:多线程std::thread

    一:概述 C++11引入了thread类,大大降低了多线程使用的复杂度,原先使用多线程只能用系统的API,无法解决跨平台问题,一套代码平台移植,对应多线程代码也必须要修改.现在在C++11中只需使用语言层面的thread可以解决这个问题. 所需头文件<thread> 二:构造函数 1.默认构造函数 thread() noexcept 一个空的std::thread执行对象 2.初始化构造函数 template<class Fn, class... Args> explicit th

  • C++11 并发指南之std::thread 详解

    上一篇博客<C++11 并发指南一(C++11 多线程初探)>中只是提到了 std::thread 的基本用法,并给出了一个最简单的例子,本文将稍微详细地介绍 std::thread 的用法. std::thread 在 <thread> 头文件中声明,因此使用 std::thread 时需要包含 <thread> 头文件. std::thread 构造 default (1) thread() noexcept; initialization (2) template

  • c++11中关于std::thread的join的详解

    std::thread是c++11新引入的线程标准库,通过其可以方便的编写与平台无关的多线程程序,虽然对比针对平台来定制化多线程库会使性能达到最大,但是会丧失了可移植性,这样对比其他的高级语言,可谓是一个不足.终于在c++11承认多线程的标准,可谓可喜可贺!!! 在使用std::thread的时候,对创建的线程有两种操作:等待/分离,也就是join/detach操作.join()操作是在std::thread t(func)后"某个"合适的地方调用,其作用是回收对应创建的线程的资源,避

  • C++中std::thread线程用法

    目录 1:std::thread的基本用法 2:std:: thread常用的成员函数 3:建立新 thread执行类别中的函数 4:建立新 thread 执行 lambda expression 5:join等待thread执行结束 6:detach不等待 thread执行结束 7:std::thread 参数传递使用引用的方法 1:std::thread的基本用法 最简单的 std::thread用法如下,调用 thread将立即同时开始执行这个新建立的线程,新线程的任务执行完毕之后, ma

  • C++ std::thread 使用方法

    目录 一.std::thread的构造和析构 二.std::thread的成员函数 三.线程间的通信 四.线程的异常处理 五.总结 总结: C++是一种高级编程语言,被广泛用于开发高性能.大规模.复杂的软件系统.其中一个强大的特性就是多线程编程,而std::thread是C++标准库提供的多线程支持的重要组成部分. std::thread是一个轻量级线程类,它允许程序员创建.启动.停止.等待线程.与其他多线程库不同,std::thread在运行时不需要显式地创建和销毁线程,而是通过构造和析构线程

  • 浅谈Java线程Thread.join方法解析

    join字面上是加入的意思,我们先看看join方法的解释和实现. /** * Waits for this thread to die. * 调用方线程(调用join方法的线程)执行等待操作,直到被调用的线程(join方法所属的线程)结束,再被唤醒 * <p> An invocation of this method behaves in exactly the same * way as the invocation * * * @throws InterruptedException *

  • Ruby多线程库(Thread)使用方法详解

    Thread是Ruby的线程库,Thread库已经内置在Ruby中,但如果想要使用线程安全的Queue.Mutex以及条件变量等,则需要手动require 'thread'. 主线程main 默认情况下,每个Ruby进程都具备一个主线程main,如果没有创建新的线程,所有的代码都将在这个主线程分支中执行. 使用Thread.main()类方法可获取当前线程组的主线程,使用Thread.current()可以获取当前正在执行的线程分支.使用Thread.list()可获取当前进程组中所有存活的线程

  • Android开发笔记之:如何安全中止一个自定义线程Thread的方法

    经研究,我推荐这种写法: 复制代码 代码如下: <SPAN xmlns="http://www.w3.org/1999/xhtml">/*自定义线程*/ class MyThread implements Runnable{  public void run() {   // TODO Auto-generated method stub //  定义自己的变量                         while(!Thread.currentThread().is

  • c++11封装thread库的方法示例

    前言 c++11在语言层面上提供了对thread的支持,由于不同的平台提供了不同线程API,在语言层面提供了对thread的支持可以大大的减小代码移植的工作量. 本文将给大家详细介绍关于c++11封装thread库的相关内容,下面话不多说了,来一起看看详细的介绍吧 基本接口要求 要求std::thread的构造函数 template< class Function, class... Args > explicit thread( Function&& f, Args&

  • Android 线程thread的两种实现方法(必看)

    这篇文章中有三点需要提前说明一下, 一:在android中有两种实现线程thread的方法: 一种是,扩展java.lang.Thread类 另一种是,实现Runnable接口 二:Thread类代表线程类,它的两个最主要的方法是: run()--包含线程运行时所执行的代码 Start()--用于启动线程 三: Handler 机制,它是Runnable和Activity交互的桥梁,在run方法中发送Message,在Handler里,通过不同的Message执行不同的任务. 下面分别给出两种线

  • C++11中std::future的具体使用方法

    C++11中的std::future是一个模板类.std::future提供了一种用于访问异步操作结果的机制.std::future所引用的共享状态不能与任何其它异步返回的对象共享(与std::shared_future相反)( std::future references shared state that is not shared with any other asynchronous return objects (as opposed to std::shared_future)).一

随机推荐