当前位置:   article > 正文

C++11 之 thread线程类_c++11 thread

c++11 thread

前言

在C++11之前,C / C++一直是一种顺序的编程语言。顺序是指所有指令都是串行执行的,即在相同的时刻,有且仅有单个CPU的程序计数器指向可执行代码的代码段,并运行代码段中的指令。而C / C++代码也总是对应地拥有一份操作系统赋予进程的包括堆、栈、可执行的(代码)及不可执行的(数据)在内的各种内存区域。

在C++11 标准中,增加了线程以及线程相关的类,很方便地支持了并发编程,使得编写的多线程程序的可移植性得到了很大的提高。

一、thread是什么?

std::thread 是 C++ 标准库中的一个类,用于创建和管理线程。它提供了一种在 C++ 中实现多线程编程的方式。

通过 std::thread,您可以创建新的线程并在其中执行函数或者可调用对象。线程可以并行地执行代码,使得您可以在同一程序中同时执行多个任务。

二、thread类构造函数

  • 构造函数接受可调用对象作为参数

构造函数接受可调用对象作为参数'func'构造函数接受可调用对象作为参数'args',创建一个新的线程对象,并执行'func'函数,函数参数为'args' 

  1. template< class Function, class... Args >
  2. explicit thread( Function&& func, Args&&... args );

 使用示例:

  1. void myFunction(int param)
  2. {
  3. std::cout << "例子1输出:" << std::endl;
  4. std::cout << "myFunction:" << param << std::endl;
  5. }
  6. std::thread myThread1(myFunction, 42);
  7. myThread1.join();
  8. int value = 10;
  9. std::thread myThread2([value](int param)
  10. {
  11. std::cout << "例子2输出:" << std::endl;
  12. std::cout << "myLambda:" << param;
  13. }, 24);
  14. myThread2.join();

输出结果: 

  • 构造函数接受成员函数指针和对象实例作为参数
  1. template< class Class, class... Args >
  2. explicit thread( Class&& obj, Args&&... args );

 使用示例:

  1. class MyClass
  2. {
  3. public:
  4. void printHelloWorld() const
  5. {
  6. std::cout << "子线程输出:" << std::endl;
  7. std::cout << "类成员函数和对象实例作为线程类thread参数:" << std::endl;
  8. }
  9. };
  10. MyClass obj;
  11. std::thread myThread(&MyClass::printHelloWorld, &obj);
  12. myThread.join();

 输出结果:

 

  • 构造函数接受函数对象(仿函数)作为参数
  1. template< class Callable, class... Args >
  2. explicit thread( Callable&& f, Args&&... args );

使用示例:

  1. struct MyClass
  2. {
  3. void operator()()
  4. {
  5. std::cout << "子线程输出" << std::endl;
  6. std::cout << "仿函数作为线程类thread参数" << std::endl;
  7. }
  8. };
  9. MyClass myClass;
  10. std::thread myThread4(myClass);
  11. myThread4.join();

结果输出:

三、thread类公共成员函数

1、get_id()

 获取线程ID,类型为std::thread::id,用于获取当前线程的ID,每个线程仅有一个唯一的ID。

使用示例:

  1. std::cout << "主线程ID:" << std::this_thread::get_id()<<std::endl;
  2. std::thread myThread([]()
  3. {
  4. std::cout << "子线程ID:" << std::this_thread::get_id()<<std::endl;
  5. });
  6. std::cout << "子线程ID:" << myThread.get_id() << std::endl;
  7. myThread.join();

结果输出:

2、join()

"join()""std::thread"的一个成员函数,用于等待线程执行完毕。调用"join()"函数将阻塞当前线程,知道被调用的线程执行完毕。

使用示例:

  1. #include <iostream>
  2. #include <thread>
  3. void myFunction() {
  4. // 线程执行的函数
  5. for (int i = 0; i < 5; ++i) {
  6. std::cout << "Thread executing..." << std::endl;
  7. }
  8. }
  9. int main() {
  10. std::thread myThread(myFunction); // 创建线程并执行 myFunction
  11. // 其他操作...
  12. myThread.join(); // 等待线程执行完成
  13. std::cout << "Main thread continues..." << std::endl;
  14. return 0;
  15. }

结果输出:

 

3、detach()

"detach()"用于将线程与实际的线程分离,分离后线程在后台继续执行,与主线程无关。主线程不再追踪和控制分离的线程。子线程任务执行完毕后,将自动是否自己占用的系统资源

使用示例:

  1. #include <iostream>
  2. #include <thread>
  3. void myFunction() {
  4. // 线程执行的函数
  5. for (int i = 0; i < 5; ++i) {
  6. std::cout << "Thread executing..." << std::endl;
  7. }
  8. }
  9. int main() {
  10. std::thread myThread(myFunction); // 创建线程并执行 myFunction
  11. // 其他操作...
  12. myThread.detach(); // 分离线程,使其在后台继续执行
  13. std::cout << "Main thread continues..." << std::endl;
  14. // 等待子线程执行完毕
  15. std::this_thread::sleep_for(std::chrono::seconds(5));
  16. return 0;
  17. }

结果输出:

 

4、joinable()

"joinable()""std::thread"类的一个成员函数,用于检查线程是否可以被"join()""detach()"。如果线程对象尚未与实际的线程关联,或者已经被"join()"或 "detach()",则该函数返回"false“,否则返回”true“

使用示例:

  1. #include <iostream>
  2. #include <thread>
  3. void myFunction() {
  4. // 线程执行的函数
  5. for (int i = 0; i < 5; ++i) {
  6. std::cout << "Thread executing..." << std::endl;
  7. }
  8. }
  9. int main() {
  10. std::thread myThread(myFunction); // 创建线程并执行 myFunction
  11. // 其他操作...
  12. if(myThread.joinable())
  13. {
  14. std::cout << "joinable:" << (myThread.joinable() ? "true" : "false") <<std::endl;
  15. myThread.join();
  16. std::cout << "joinable:" << (myThread.joinable() ? "true" : "false") <<std::endl;
  17. }
  18. std::cout << "Main thread continues..." << std::endl;
  19. return 0;
  20. }

结果输出:

 

5、swap

”swap“用于交换两个线程对象的状态。它将两个线程对象之间的执行内容进行交换,使得一个线程对象接管另一个线程对象的执行。

使用示例:

  1. #include <iostream>
  2. #include <thread>
  3. void myFunction1() {
  4. std::cout << "Thread 1 executing..." << std::endl;
  5. }
  6. void myFunction2() {
  7. std::cout << "Thread 2 executing..." << std::endl;
  8. }
  9. int main() {
  10. std::thread thread1(myFunction1); // 创建线程1,并执行 myFunction1
  11. std::thread thread2(myFunction2); // 创建线程2,并执行 myFunction2
  12. // 其他操作...
  13. thread1.swap(thread2); // 交换两个线程对象的执行内容
  14. // 其他操作...
  15. thread1.join(); // 等待线程1执行完成
  16. thread2.join(); // 等待线程2执行完成
  17. std::cout << "Main thread continues..." << std::endl;
  18. return 0;
  19. }

结果输出:

 

四、thread类静态函数

1、hardware_concurrency()

"hardware_concurrency()"用于获取系统支持的并发线程数。它返回一个表示支持的并发线程数的无符号整数值。

使用示例:

  1. #include <iostream>
  2. #include <thread>
  3. int main() {
  4. unsigned int numThreads = std::thread::hardware_concurrency();
  5. std::cout << "Number of concurrent threads supported: " << numThreads << std::endl;
  6. return 0;
  7. }

结果输出:


 

总结

以上就是对C++11Thread的简单介绍,后续将为大家介绍C++的线程通信。

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/笔触狂放9/article/detail/153471
推荐阅读
相关标签
  

闽ICP备14008679号