Linux环境下C++并发编程模型 - 问答

在Linux环境下，C++并发编程模型主要依赖于POSIX线程库（pthread）和C++11引入的线程库。以下是一些常见的并发编程模型：

1. POSIX Threads (pthread)

POSIX Threads是一个跨平台的线程库，提供了创建和管理线程的API。

基本概念

线程（Thread）：程序执行流的最小单元。
互斥锁（Mutex）：用于保护共享资源，防止多个线程同时访问。
条件变量（Condition Variable）：用于线程间的同步，允许线程等待某个条件成立。
读写锁（Read-Write Lock）：允许多个读线程同时访问共享资源，但写线程独占访问。

示例代码

#include <pthread.h>
#include <iostream>

pthread_mutex_t mutex;
int shared_resource = 0;

void* thread_func(void* arg) {
    pthread_mutex_lock(&mutex);
    shared_resource++;
    std::cout << "Thread ID: " << pthread_self() << ", Shared Resource: " << shared_resource << std::endl;
    pthread_mutex_unlock(&mutex);
    return nullptr;
}

int main() {
    pthread_t thread1, thread2;
    pthread_mutex_init(&mutex, nullptr);

    pthread_create(&thread1, nullptr, thread_func, nullptr);
    pthread_create(&thread2, nullptr, thread_func, nullptr);

    pthread_join(thread1, nullptr);
    pthread_join(thread2, nullptr);

    pthread_mutex_destroy(&mutex);
    return 0;
}

2. C++11 Thread Library

C++11引入了标准库中的线程支持，提供了更现代和易用的接口。

基本概念

std::thread：用于创建和管理线程。
std::mutex：互斥锁。
std::lock_guard：RAII风格的互斥锁管理。
std::condition_variable：条件变量。
std::atomic：原子操作，用于无锁编程。

示例代码

#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> lck(mtx);
    cv.wait(lck, []{return ready;});
    std::cout << "Thread " << id << std::endl;
}

void go() {
    std::lock_guard<std::mutex> lck(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::this_thread::sleep_for(std::chrono::seconds(1));
    go();
    for (auto& th : threads) {
        th.join();
    }
    return 0;
}

3. 异步编程模型

C++11引入了std::async和std::future，提供了更高级的异步编程模型。

示例代码

#include <iostream>
#include <future>

int add(int x, int y) {
    return x + y;
}

int main() {
    std::future<int> result = std::async(std::launch::async, add, 3, 4);
    std::cout << "Waiting for result..." << std::endl;
    std::cout << "Result: " << result.get() << std::endl;
    return 0;
}

4. 并发容器和算法

C++标准库提供了一些并发安全的容器和算法，例如std::atomic、std::shared_mutex等。

示例代码

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

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

void increment_counter(int iterations) {
    for (int i = 0; i < iterations; ++i) {
        atomic_counter++;
    }
}

int main() {
    std::vector<std::thread> threads;
    int iterations = 100000;

    for (int i = 0; i < 10; ++i) {
        threads.emplace_back(increment_counter, iterations);
    }

    for (auto& th : threads) {
        th.join();
    }

    std::cout << "Final Counter Value: " << atomic_counter.load() << std::endl;
    return 0;
}

这些模型和工具可以帮助你在Linux环境下进行高效的C++并发编程。选择合适的模型取决于你的具体需求和应用场景。

0 赞

0 踩