赞
踩
在C++11之前,C / C++一直是一种顺序的编程语言。顺序是指所有指令都是串行执行的,即在相同的时刻,有且仅有单个CPU的程序计数器指向可执行代码的代码段,并运行代码段中的指令。而C / C++代码也总是对应地拥有一份操作系统赋予进程的包括堆、栈、可执行的(代码)及不可执行的(数据)在内的各种内存区域。
在C++11 标准中,增加了线程以及线程相关的类,很方便地支持了并发编程,使得编写的多线程程序的可移植性得到了很大的提高。
std::thread
是 C++ 标准库中的一个类,用于创建和管理线程。它提供了一种在 C++ 中实现多线程编程的方式。
通过 std::thread
,您可以创建新的线程并在其中执行函数或者可调用对象。线程可以并行地执行代码,使得您可以在同一程序中同时执行多个任务。
构造函数接受可调用对象作为参数'func'构造函数接受可调用对象作为参数'args',创建一个新的线程对象,并执行'func'函数,函数参数为'args'
- template< class Function, class... Args >
- explicit thread( Function&& func, Args&&... args );
使用示例:
- void myFunction(int param)
- {
- std::cout << "例子1输出:" << std::endl;
- std::cout << "myFunction:" << param << std::endl;
- }
-
- std::thread myThread1(myFunction, 42);
- myThread1.join();
-
- int value = 10;
- std::thread myThread2([value](int param)
- {
- std::cout << "例子2输出:" << std::endl;
- std::cout << "myLambda:" << param;
- }, 24);
- myThread2.join();
输出结果:
- template< class Class, class... Args >
- explicit thread( Class&& obj, Args&&... args );
使用示例:
- class MyClass
- {
- public:
- void printHelloWorld() const
- {
- std::cout << "子线程输出:" << std::endl;
- std::cout << "类成员函数和对象实例作为线程类thread参数:" << std::endl;
- }
- };
-
- MyClass obj;
- std::thread myThread(&MyClass::printHelloWorld, &obj);
- myThread.join();
输出结果:
- template< class Callable, class... Args >
- explicit thread( Callable&& f, Args&&... args );
使用示例:
- struct MyClass
- {
- void operator()()
- {
- std::cout << "子线程输出" << std::endl;
- std::cout << "仿函数作为线程类thread参数" << std::endl;
- }
- };
-
- MyClass myClass;
- std::thread myThread4(myClass);
- myThread4.join();
结果输出:
获取线程ID,类型为std::thread::id,用于获取当前线程的ID,每个线程仅有一个唯一的ID。
使用示例:
- std::cout << "主线程ID:" << std::this_thread::get_id()<<std::endl;
-
- std::thread myThread([]()
- {
- std::cout << "子线程ID:" << std::this_thread::get_id()<<std::endl;
- });
- std::cout << "子线程ID:" << myThread.get_id() << std::endl;
- myThread.join();
结果输出:
"join()"是"std::thread"的一个成员函数,用于等待线程执行完毕。调用"join()"函数将阻塞当前线程,知道被调用的线程执行完毕。
使用示例:
- #include <iostream>
- #include <thread>
-
- void myFunction() {
- // 线程执行的函数
- for (int i = 0; i < 5; ++i) {
- std::cout << "Thread executing..." << std::endl;
- }
- }
-
- int main() {
- std::thread myThread(myFunction); // 创建线程并执行 myFunction
-
- // 其他操作...
-
- myThread.join(); // 等待线程执行完成
-
- std::cout << "Main thread continues..." << std::endl;
-
- return 0;
- }
结果输出:
"detach()"用于将线程与实际的线程分离,分离后线程在后台继续执行,与主线程无关。主线程不再追踪和控制分离的线程。子线程任务执行完毕后,将自动是否自己占用的系统资源
使用示例:
- #include <iostream>
- #include <thread>
-
- void myFunction() {
- // 线程执行的函数
- for (int i = 0; i < 5; ++i) {
- std::cout << "Thread executing..." << std::endl;
- }
- }
-
- int main() {
- std::thread myThread(myFunction); // 创建线程并执行 myFunction
-
- // 其他操作...
-
- myThread.detach(); // 分离线程,使其在后台继续执行
-
- std::cout << "Main thread continues..." << std::endl;
-
- // 等待子线程执行完毕
- std::this_thread::sleep_for(std::chrono::seconds(5));
-
- return 0;
- }
结果输出:
"joinable()"是"std::thread"类的一个成员函数,用于检查线程是否可以被"join()"或"detach()"。如果线程对象尚未与实际的线程关联,或者已经被"join()"或 "detach()",则该函数返回"false“,否则返回”true“。
使用示例:
- #include <iostream>
- #include <thread>
-
- void myFunction() {
- // 线程执行的函数
- for (int i = 0; i < 5; ++i) {
- std::cout << "Thread executing..." << std::endl;
- }
- }
-
- int main() {
- std::thread myThread(myFunction); // 创建线程并执行 myFunction
-
- // 其他操作...
-
- if(myThread.joinable())
- {
- std::cout << "joinable:" << (myThread.joinable() ? "true" : "false") <<std::endl;
-
- myThread.join();
-
- std::cout << "joinable:" << (myThread.joinable() ? "true" : "false") <<std::endl;
- }
-
- std::cout << "Main thread continues..." << std::endl;
-
- return 0;
- }
结果输出:
”swap“用于交换两个线程对象的状态。它将两个线程对象之间的执行内容进行交换,使得一个线程对象接管另一个线程对象的执行。
使用示例:
- #include <iostream>
- #include <thread>
-
- void myFunction1() {
- std::cout << "Thread 1 executing..." << std::endl;
- }
-
- void myFunction2() {
- std::cout << "Thread 2 executing..." << std::endl;
- }
-
- int main() {
- std::thread thread1(myFunction1); // 创建线程1,并执行 myFunction1
- std::thread thread2(myFunction2); // 创建线程2,并执行 myFunction2
-
- // 其他操作...
-
- thread1.swap(thread2); // 交换两个线程对象的执行内容
-
- // 其他操作...
-
- thread1.join(); // 等待线程1执行完成
- thread2.join(); // 等待线程2执行完成
-
- std::cout << "Main thread continues..." << std::endl;
-
- return 0;
- }
结果输出:
"hardware_concurrency()"用于获取系统支持的并发线程数。它返回一个表示支持的并发线程数的无符号整数值。
使用示例:
- #include <iostream>
- #include <thread>
-
- int main() {
- unsigned int numThreads = std::thread::hardware_concurrency();
- std::cout << "Number of concurrent threads supported: " << numThreads << std::endl;
-
- return 0;
- }
结果输出:
以上就是对C++11Thread的简单介绍,后续将为大家介绍C++的线程通信。
Copyright © 2003-2013 www.wpsshop.cn 版权所有,并保留所有权利。