Explication détaillée des primitives de synchronisation dans la programmation simultanée C++

Dans la programmation multi-thread C++, le rôle des primitives de synchronisation est de garantir l'exactitude de plusieurs threads accédant aux ressources partagées. Elle comprend : Mutex (Mutex) : protège les ressources partagées et empêche l'accès simultané (Condition Variable) : Le thread ; attend que des conditions spécifiques soient remplies avant de poursuivre l'exécution. Opération atomique : garantit que l'opération est exécutée de manière ininterrompue.

Explication détaillée des primitives de synchronisation dans la programmation simultanée C++

Dans la programmation multi-thread, les primitives de synchronisation sont cruciales, car elles peuvent garantir l'exactitude lorsque plusieurs threads accèdent à des ressources partagées. C++ fournit un riche ensemble de primitives de synchronisation, notamment des verrous mutex, des variables de condition et des opérations atomiques.

Mutex (Mutex)

Mutex est un mécanisme de synchronisation utilisé pour protéger les ressources partagées. Lorsqu'un thread acquiert un verrou mutex, les autres threads seront bloqués jusqu'à ce que le verrou mutex soit libéré. En C++, vous pouvez utiliser la classe std::mutex pour implémenter un verrou mutex : std::mutex 类来实现互斥锁：

std::mutex mtx;
// ...
{
    // 获取互斥锁
    std::lock_guard<std::mutex> lock(mtx);
    // 临界区
} // 互斥锁在离开作用域时自动释放

条件变量 (Condition Variable)

条件变量允许线程等待某个特定条件满足才继续执行。在 C++ 中，可以使用 std::condition_variable

std::condition_variable cv;
// ...
{
    std::unique_lock<std::mutex> lock(mtx);
    // 等待条件满足
    cv.wait(lock);
    // 执行条件满足后要执行的代码
}

Variable de condition

La variable de condition permet à un thread d'attendre qu'une condition spécifique soit remplie avant de continuer. éxécuter . En C++, vous pouvez utiliser la classe std::condition_variable pour implémenter des variables de condition :

std::atomic<int> counter;
// ...
counter++; // 原子地增加 counter 的值

Opérations atomiques

Les opérations atomiques garantissent qu'une opération est exécutée de manière ininterrompue. En C++, vous pouvez utiliser la bibliothèque atomique pour effectuer des opérations atomiques :

std::atomic<int> counter;
std::mutex mtx;

// 写入线程
void write_thread() {
    while (true) {
        // 原子地增加计数器
        counter++;
    }
}

// 读取线程
void read_thread() {
    while (true) {
        // 保护地读取计数器
        std::lock_guard<std::mutex> lock(mtx);
        std::cout << "Counter: " << counter << std::endl;
    }
}

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

🎜Cas pratique🎜🎜🎜Considérons un programme avec un compteur partagé et un fil d'écriture. Le fil d'écriture doit incrémenter atomiquement le compteur, tandis que le fil de lecture doit lire le compteur avec prudence : 🎜rrreee

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!