浅谈C++之线程管理

一、基本介绍

        C++11 提供了强大的多线程支持，涵盖了线程的创建、同步、共享数据管理等，极大简化了多线程编程的复杂性。

• 线程：一个程序执行流的最小单位。每个线程都有自己的程序计数器、栈、寄存器等。
• 多线程：程序可以同时执行多个任务，提高了程序的并发能力。
• 并行与并发：并行是多个线程在多个处理器上同时运行；并发是多个线程在同一处理器上通过时间片轮转方式运行。

二、关键概念和示例

1. 包含头文件

首先，你需要包含头文件<thread>来使用线程库。

#include <thread>

2. 创建线程

使用std::thread类来创建线程。你可以将一个函数或对象作为参数传递给std::thread的构造函数，这个函数或对象将在新线程中执行。

#include <iostream>
#include <thread>

void hello() {
    std::cout << "Hello from a thread!" << std::endl;
}

int main() {
    std::thread t(hello);
    t.join();  // 等待线程t完成
    return 0;
}

3. 传递参数给线程

你可以将参数传递给线程函数。

#include <iostream>
#include <thread>

void print_message(const std::string& message) {
    std::cout << message << std::endl;
}

int main() {
    std::string message = "Hello from another thread!";
    std::thread t(print_message, message);
    t.join();
    return 0;
}

4. 线程的生命周期

• join(): 阻塞调用线程，直到被join的线程完成执行。
• detach(): 允许线程独立执行。主线程可以继续执行，而不需要等待子线程完成。

std::thread t(hello);
t.detach();  // 线程t现在独立执行

5. 线程同步

使用互斥锁（std::mutex）和条件变量（std::condition_variable）来同步线程。

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>

std::mutex mtx;
std::condition_variable cv;
bool ready = false;

void print_id(int id) {
    std::unique_lock<std::mutex> lock(mtx);
    while (!ready) { cv.wait(lock); }
    std::cout << "Thread " << id << '\n';
}

void go() {
    std::unique_lock<std::mutex> lock(mtx);
    ready = true;
    cv.notify_all();
}

int main() {
    std::thread threads[10];
    for (int i = 0; i < 10; ++i)
        threads[i] = std::thread(print_id, i);
    
    std::cout << "10 threads ready to race...\n";
    go();
    for (auto& th : threads) th.join();
    return 0;
}

6. 线程局部存储

使用thread_local关键字定义线程局部存储，每个线程都有自己的变量副本。

#include <iostream>
#include <thread>

thread_local int x = 0;

void increment() {
    x = x + 1;
    std::cout << "Thread " << std::this_thread::get_id() << " x = " << x << std::endl;
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);
    t1.join();
    t2.join();
    return 0;
}

7. 原子操作

使用std::atomic来处理简单的同步需求。

#include <iostream>
#include <thread>
#include <atomic>

std::atomic<int> count(0);

void add() {
    for (int i = 0; i < 10000; ++i) {
        count += 1;
    }
}

int main() {
    std::thread t1(add);
    std::thread t2(add);
    t1.join();
    t2.join();
    std::cout << "Count: " << count << std::endl;
    return 0;
}

原文地址：https://blog.csdn.net/a876106354/article/details/142545983

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！