C++引擎的多线程处理策略

在C++中，实现多线程处理主要依赖于C++11标准引入的<thread>库

线程创建：使用std::thread类创建线程。例如：

#include<iostream>
#include<thread>

void myFunction() {
    std::cout << "This is a new thread."<< std::endl;
}

int main() {
    std::thread t(myFunction); // 创建一个新线程并运行myFunction
    t.join(); // 等待线程完成
    return 0;
}

线程同步：为了避免数据竞争和同步问题，可以使用互斥锁（std::mutex）来保护共享数据。例如：

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

std::mutex mtx; // 全局互斥锁
int sharedData = 0;

void increment(int n) {
    for (int i = 0; i < n; ++i) {
        mtx.lock(); // 加锁
        ++sharedData;
        mtx.unlock(); // 解锁
    }
}

int main() {
    std::thread t1(increment, 100000);
    std::thread t2(increment, 100000);

    t1.join();
    t2.join();

    std::cout << "Shared data: "<< sharedData<< std::endl;
    return 0;
}

条件变量：std::condition_variable允许线程等待某个条件成立。例如，生产者-消费者模型：

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

std::mutex mtx;
std::condition_variable cv;
std::queue<int> dataQueue;

void producer() {
    for (int i = 0; i < 10; ++i) {
        std::unique_lock<std::mutex> lock(mtx);
        dataQueue.push(i);
        cv.notify_one(); // 通知消费者有新数据
        lock.unlock();
    }
}

void consumer() {
    while (true) {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, [] { return !dataQueue.empty(); }); // 等待有数据
        int data = dataQueue.front();
        dataQueue.pop();
        lock.unlock();

        if (data == -1) break; // 特殊值表示结束

        std::cout << "Consumed: "<< data<< std::endl;
    }
}

int main() {
    std::thread p(producer);
    std::thread c(consumer);

    p.join();

    {
        std::unique_lock<std::mutex> lock(mtx);
        dataQueue.push(-1); // 添加特殊值表示结束
        cv.notify_one();
    }

    c.join();
    return 0;
}

原子操作：std::atomic提供了一种无锁的方式来保证原子性操作。例如：

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

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

void increment(int n) {
    for (int i = 0; i < n; ++i) {
        ++sharedData;
    }
}

int main() {
    std::thread t1(increment, 100000);
    std::thread t2(increment, 100000);

    t1.join();
    t2.join();

    std::cout << "Shared data: "<< sharedData<< std::endl;
    return 0;
}

线程池：为了避免频繁创建和销毁线程带来的开销，可以使用线程池来管理线程。C++标准库没有直接提供线程池，但可以使用第三方库如boost.asio或自行实现一个简单的线程池。

这些策略可以根据不同的场景和需求进行组合使用，以实现高效的多线程处理。请注意，正确地使用多线程需要仔细考虑线程安全、同步和数据竞争等问题，以避免出现错误和未定义行为。

最新问答

相关标签