C++ std::thread 使用方法

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

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

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

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

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()
        // 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()
        // 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)
            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使用内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！
您可能感兴趣的文章:
C++11中std::thread线程实现暂停(挂起)功能
C++中std::thread线程用法
C++11 并发指南之std::thread 详解
c++11中关于std::thread的join的详解
C++11并发编程:多线程std::thread
在std::thread中创建并管理QEventLoop的全面解析
2023-05-05
2023-06-06
2023-05-05
2023-05-05
2023-05-05
2023-05-05
2023-05-05
2023-05-05
2021-11-19
2021-11-09
2021-11-05
2021-10-26
电脑版 - 返回首页
2006-2023 脚本之家 JB51.Net , All Rights Reserved.
苏ICP备14036222号