std::lock_guard exemple, expliquer pourquoi il fonctionne

J'ai atteint un point dans mon projet qui nécessite une communication entre les threads sur les ressources que peut-être bien écrit, donc la synchronisation est un must. Cependant je ne comprends pas vraiment la synchronisation à rien d'autre que le niveau de base.

Considère que le dernier exemple dans ce lien: http://www.bogotobogo.com/cplusplus/C11/7_C11_Thread_Sharing_Memory.php

#include <iostream>
#include <thread>
#include <list>
#include <algorithm>
#include <mutex>

using namespace std;

//a global variable
std::list<int>myList;

//a global instance of std::mutex to protect global variable
std::mutex myMutex;

void addToList(int max, int interval)
{
    //the access to this function is mutually exclusive
    std::lock_guard<std::mutex> guard(myMutex);
    for (int i = 0; i < max; i++) {
        if( (i % interval) == 0) myList.push_back(i);
    }
}

void printList()
{
    //the access to this function is mutually exclusive
    std::lock_guard<std::mutex> guard(myMutex);
    for (auto itr = myList.begin(), end_itr = myList.end(); itr != end_itr; ++itr ) {
        cout << *itr << ",";
    }
}

int main()
{
    int max = 100;

    std::thread t1(addToList, max, 1);
    std::thread t2(addToList, max, 10);
    std::thread t3(printList);

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

    return 0;
}

L'exemple montre comment trois fils, deux écrivains et un lecteur accède à une ressource commune(liste).

Deux fonctions globales sont utilisées: l'une qui est utilisé par les deux threads d'écriture, et celle utilisée par le thread de lecture. Ces deux fonctions utilisent un lock_guard pour verrouiller la même ressource, la liste.

Maintenant, voici ce que j'ai juste ne peut pas envelopper la tête autour de: Le lecteur utilise un verrou dans un autre champ que les deux threads d'écriture, mais encore verrouille la même ressource. Comment cela peut-il fonctionner? Ma compréhension limitée des mutex se prête bien à l'écrivain de fonction, vous avez deux threads en utilisant la même fonction. Je peux comprendre que, une vérification est faite à droite lorsque vous êtes sur le point d'entrer dans la zone protégée, et si quelqu'un d'autre est déjà à l'intérieur, vous attendre.

Mais quand le champ est différent? Cela semble indiquer qu'il y a une sorte de mécanisme plus puissant que le processus lui-même, une sorte d'environnement d'exécution de blocage de l'exécution de la "fin" de thread. Mais je pensais qu'il n'y avait pas de telles choses en c++. Donc, je suis à une perte.

Ce qu'il se passe sous le capot?

Je voudrais ajouter que le mutex de verrouillage est atomique. Espérons que cette aide.

OriginalL'auteur Deviatore | 2016-02-07