Le concept clé de la programmation multithread C++ est de savoir comment synchroniser les threads ?

Concepts clés de synchronisation multi-thread C++ : Verrouillage mutex : assurez-vous que la section critique n'est accessible que par un seul thread. Variables de condition : les threads peuvent être réveillés lorsque des conditions spécifiques sont remplies. Fonctionnement atomique : une instruction CPU unique sans interruption pour garantir l'atomicité des modifications de variables partagées.

Concepts clés de la programmation multithread C++ : synchronisation des threads

La synchronisation des threads est un élément crucial de la programmation multithread. Elle garantit que plusieurs threads peuvent accéder en toute sécurité aux ressources partagées et éviter les conflits et la corruption des données. Ce qui suit présente les concepts clés de la synchronisation des threads en C++ :

Mutex :

Mutex (mutex) est un mécanisme de contrôle d'accès qui permet à un seul thread d'accéder à la section critique à la fois, c'est-à-dire qu'un accès synchrone est requis zone de code. L'utilisation d'un verrou mutex peut empêcher plusieurs threads de modifier des variables partagées en même temps, provoquant ainsi une corruption des données.

std::mutex mtx;  // 定义互斥锁对象

void someFunction() {
    std::lock_guard<std::mutex> lock(mtx);  // 在进入临界区前加锁
    // 访问临界区代码
}

Variables conditionnelles :

Les variables conditionnelles permettent aux threads d'être réveillés lorsque des conditions spécifiques sont remplies. Ceci est utile dans la programmation multithread coopérative, par exemple lorsqu'un thread attend qu'un autre thread produise des données.

std::condition_variable cv;  // 定义条件变量对象
std::mutex mtx;  // 关联的互斥锁对象

void produce() {
    std::lock_guard<std::mutex> lock(mtx);  // 加锁
    // 产生数据
    cv.notify_all();  // 通知所有等待此条件的线程
}

void consume() {
    std::unique_lock<std::mutex> lock(mtx);  // 加锁
    cv.wait(lock);  // 等待 `produce()` 函数生产数据
    // 消费数据
}

Opérations atomiques :

Les opérations atomiques sont des instructions de processeur unique qui ne peuvent pas être interrompues par d'autres threads, garantissant que les modifications apportées aux variables partagées sont atomiques.

std::atomic<int> count;  // 定义原子变量

void incrementCount() {
    count++;  // 原子方式增加 `count`
}

Cas pratique :

Considérons le programme multi-thread suivant :

std::vector<int> numbers;  // 共享的整型数组

void addNumber(int n) {
    numbers.push_back(n);
}

int main() {
    std::thread t1(addNumber, 1);
    std::thread t2(addNumber, 2);
    t1.join();
    t2.join();
    
    std::cout << "Numbers in the vector: ";
    for (int n : numbers) {
        std::cout << n << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

Dans cet exemple, numbers le tableau est une ressource partagée accessible simultanément par plusieurs threads. Si des mesures de synchronisation ne sont pas prises, des conditions de concurrence critique peuvent survenir, entraînant une corruption des données.

Pour accéder au tableau en toute sécurité, nous pouvons utiliser un verrou mutex :

void addNumber(int n) {
    std::lock_guard<std::mutex> lock(mtx);  // 在访问数组前加锁
    numbers.push_back(n);
}

De cette façon, un seul thread peut accéder au tableau à la fois, garantissant ainsi l'intégrité des données.

Sortie :

Numbers in the vector: 1 2 

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!