How to use C++ for efficient concurrent programming?

How to use C for efficient concurrent programming?

Introduction:
With the development of computer systems, the popularization of multi-core technology, and the increase in demand for high concurrent processing, concurrent programming has become more and more important. C is a powerful programming language with a rich set of concurrent programming tools and libraries. This article explains how to use C for efficient concurrent programming and provides some sample code.

1. Threads and thread management:

1. Creating threads:
   C 11 introduces the <thread></thread> header file, through std The ::thread class makes it easy to create new threads. The following is sample code to create a thread:

#include <iostream>
#include <thread>

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

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

2. Thread management:
   std::thread Instances of classes can join() Or detach(), when calling join(), the main thread will wait for the thread to complete execution, while detach() will let the new thread in the background run. The following is a sample code for thread management:

#include <iostream>
#include <thread>

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

int main() {
    std::thread t(myFunction);  // 创建一个新线程
    t.detach();  // 将线程设置为后台运行
    // 主线程可以继续执行其他任务
    return 0;
}

2. Mutex lock and condition variable:

1. Mutex lock:
   Mutex lock (Mutex) It is used to protect shared resources and avoid conflicts caused by multiple threads accessing resources at the same time. The following is a sample code for a mutex lock:

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

std::mutex mtx;  // 创建互斥锁

void myFunction() {
    mtx.lock();  // 加锁
    std::cout << "This is a critical section." << std::endl;
    mtx.unlock();  // 解锁
}

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

2. Condition variable:
   Condition variable (Condition Variable) is used for synchronization between threads and can block one thread until other threads are satisfied A certain condition wakes it up. The following is a sample code for condition variables:

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

std::mutex mtx;  // 创建互斥锁
std::condition_variable cv;  // 创建条件变量
bool ready = false;  // 条件

void myFunction() {
    std::unique_lock<std::mutex> ul(mtx);
    cv.wait(ul, []{ return ready; });  // 阻塞线程直到满足条件
    std::cout << "This is a new thread." << std::endl;
}

int main() {
    std::thread t(myFunction);
    {
        std::lock_guard<std::mutex> lg(mtx);
        ready = true;
    }
    cv.notify_one();  // 唤醒等待条件的线程
    t.join();
    return 0;
}

3. Concurrent containers:
C 11 introduces multiple concurrent containers to solve the problem of multi-threaded access to shared data, including std ::vector, std::map, std::queue, etc. The following is sample code using a concurrent container:

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

std::vector<int> sharedVector;  // 共享容器
std::mutex mtx;  // 创建互斥锁

void producer() {
    for (int i = 0; i < 10; ++i) {
        std::lock_guard<std::mutex> lg(mtx);
        sharedVector.push_back(i);
    }
}

void consumer() {
    for (int i = 0; i < 10; ++i) {
        std::lock_guard<std::mutex> lg(mtx);
        if (!sharedVector.empty()) {
            std::cout << sharedVector.back() << std::endl;
            sharedVector.pop_back();
        }
    }
}

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

Conclusion:
Efficient concurrent programming in C is an important technical requirement. By having a deep understanding of C's threads, mutexes, condition variables, and concurrent containers, we can better handle data sharing and synchronization issues in multi-threaded programming, and improve program performance and efficiency.

Reference:

1. C Reference - <thread></thread>：https://www.cplusplus.com/reference/thread/
2. C Reference - <mutex></mutex>：https://www.cplusplus.com/reference/mutex/
3. C Reference - <condition_variable></condition_variable>： https://www.cplusplus.com/reference/condition_variable/

The above is the detailed content of How to use C++ for efficient concurrent programming?. For more information, please follow other related articles on the PHP Chinese website!