C++多线程常用方法

在 C++ 中，线程干系功能告急通过头文件提供的类和函数来实现，以下是一些常用的线程接口方法和利用本领：
std::thread类

构造函数：
可以通过传入可调用对象（如函数指针、函数对象、lambda 表达式等）来创建一个线程实例，启动一个新线程去实行对应的任务。比方：

1. #include <iostream>
2. #include <thread>
4. void hello() {
5.     std::cout << "Hello from thread!" << std::endl;
6. }
8. int main() {
9.     std::thread t(hello);  // 创建线程t并开始执行hello函数
10.     t.join();  // 等待线程t执行完毕
11.     return 0;
12. }

复制代码

这里std::thread t(hello)就是利用函数指针hello创建线程，新线程会实行hello函数里的代码。
join方法：
用于壅闭当火线程，直到被调用的线程实行完成。比如在上面的main函数中，t.join()会让main线程停息，等候t线程把hello函数实行完后再继续往下实行。
detach方法：
将线程分离，使得线程在配景独立运行，不再与创建它的std::thread对象关联。今后，无法再通过该std::thread对象对这个线程举行控制（比如不能再调用join了）。示例：

1. #include <iostream>
2. #include <thread>
4. void func() {
5.     // 线程执行的函数内容
6.     std::cout << "Thread is running independently." << std::endl;
7. }
9. int main() {
10.     std::thread t(func);
11.     t.detach();  // 分离线程t
12.     // 主线程继续执行其他操作，不用等待t线程结束
13.     std::cout << "Main thread continues." << std::endl;
14.     return 0;
15. }

复制代码

线程传参
向线程函数通报参数时，必要包管参数在通报时是有效的，且在被调用函数实行期间一连有效（比如克制传引用指向临时对象等情况）。比方：

1. #include <iostream>
2. #include <thread>
4. void print_num(int num) {
5.     std::cout << "The number is: " << num << std::endl;
6. }
8. int main() {
9.     int num = 10;
10.     std::thread t(print_num, num);  // 传递普通变量num作为参数
11.     t.join();
12.     return 0;
13. }

复制代码

如果要通报类对象等更复杂的情况，要注意拷贝、移动语义等干系题目，确保参数通报的准确性。
线程 ID 获取
可以通过std::this_thread::get_id获取当火线程的线程 ID，大概通过std::thread对象的get_id成员函数获取对应的线程 ID，用于标识和区分差别线程。示例：

1. #include <iostream>
2. #include <thread>
4. void show_thread_id() {
5.     std::cout << "Thread ID: " << std::this_thread::get_id() << std::endl;
6. }
8. int main() {
9.     std::thread t(show_thread_id);
10.     std::cout << "Main thread ID: " << std::this_thread::get_id() << std::endl;
11.     t.join();
12.     return 0;
13. }

复制代码

线程同步干系（比方互斥量等，用于办理多线程访问共享资源辩论题目）

std::mutex（互斥量）：
通过lock和unlock方法对共享资源举行加锁息争锁，确保同一时候只有一个线程能访问被掩护的共享资源。比方：

1. #include <iostream>
2. #include <thread>
3. #include <mutex>
5. std::mutex mtx;
6. int shared_data = 0;
8. void increment() {
9.     for (int i = 0; i < 1000; ++i) {
10.         mtx.lock();  // 加锁
11.         shared_data++;
12.         mtx.unlock();  // 解锁
13.     }
14. }
16. int main() {
17.     std::thread t1(increment);
18.     std::thread t2(increment);
19.     t1.join();
20.     t2.join();
21.     std::cout << "Shared data value: " << shared_data << std::endl;
22.     return 0;
23. }

复制代码

也可以利用std::lock_guard等 RAII（Resource Acquisition Is Initialization）机制的类来更方便、安全地管理互斥量的生命周期，主动完成加锁息争锁，如：

1. #include <iostream>
2. #include <thread>
3. #include <mutex>
5. std::mutex mtx;
6. int shared_data = 0;
8. void increment() {
9.     for (int i = 0; i < 1000; ++i) {
10.         std::lock_guard<std::mutex> guard(mtx);  // 构造时加锁，析构时自动解锁
11.         shared_data++;
12.     }
13. }
15. int main() {
16.     std::thread t1(increment);
17.     std::thread t2(increment);
18.     t1.join();
19.     t2.join();
20.     std::cout << "Shared data value: " << shared_data << std::endl;
21.     return 0;
22. }

复制代码

std::condition_variable（条件变量）：
常和互斥量共同利用，用于线程间的同步，实现一个线程等候某个条件满足后再继续实行的功能。比如一个线程等候另一个线程修改共享资源到达某个条件后再举行后续利用，典范用法如下：

1. #include <iostream>
2. #include <thread>
3. #include <mutex>
4. #include <condition_variable>
6. std::mutex mtx;
7. std::condition_variable cv;
8. bool ready = false;
10. void wait_for_signal() {
11.     std::unique_lock<std::mutex> lck(mtx);
12.     cv.wait(lck, []{ return ready; });  // 等待条件满足（ready为true）
13.     std::cout << "Received signal and continue." << std::endl;
14. }
16. void send_signal() {
17.     {
18.         std::lock_guard<std::mutex> lck(mtx);
19.         ready = true;
20.     }
21.     cv.notify_one();  // 通知等待在该条件变量上的一个线程
22. }
24. int main() {
25.     std::thread t1(wait_for_signal);
26.     std::thread t2(send_signal);
27.     t1.join();
28.     t2.join();
29.     return 0;
30. }

复制代码

这些就是 C++ 中线程干系的一些告急接口方法及其根本利用方式，在实际多线程编程中，通常必要综合运用它们来实现高效、准确的并发步伐逻辑。