Devrais-je protéger les opérations sur les types primitifs avec des mutex pour être thread-safe en C++?

Question

Quelle est la meilleure approche pour atteindre la sécurité des threads pour des opérations plutôt simples?

Tenir compte d'une paire de fonctions:

void setVal(int val) 
{ 
    this->_val = val; 
} 

int getVal() { 
    return this->_val; 
} 

Étant donné que même les affectations de types primitifs ne sont pas garantis atomiques, dois-je modifier tous les getter et setter dans le programme de la manière suivante pour être thread-safe ?

void setVal(int val) 
{ 
    this->_mutex.lock(); 
    this->_val = val; 
    this->_mutex.unlock(); 
} 

int getVal() { 
    this->_mutex.lock(); 
    int result = this->_val; 
    this->_mutex.unlock(); 
    return result; 
} 

Answer 1

Utilisez-vous _val dans plusieurs threads? Si non, alors non, vous n'avez pas besoin de synchroniser l'accès. S'il est utilisé à partir de plusieurs threads, alors oui, vous devez synchroniser l'accès, soit en utilisant un mutex, soit en utilisant un type atomique (comme std::atomic<T> en C++ 0x, bien que d'autres bibliothèques de threads aient aussi des types atomiques non standard).).

Answer 2

Les mutex sont très coûteux, car ils peuvent être partagés entre les processus. Si l'état auquel vous limitez l'accès est seulement contraint aux threads dans votre processus actuel, optez pour quelque chose de moins lourd, comme une section critique ou un sémaphore.

Answer 3

int getVal() { 
    this->_mutex.lock(); 
    int result = this->_val; 
    this->_mutex.unlock(); 
    return result; 
} 

Qu'espérez-vous accomplir avec cela? Bien sûr, vous avez arrêté this->_val de changer avant de sauvegarder dans result mais il peut encore changer avant que le résultat soit retourné, - ou entre le retour et l'assignation à ce que vous lui avez assigné - ou une microseconde plus tard. Peu importe ce que vous faites, vous allez juste obtenir un instantané d'une cible en mouvement. Faites avec.

void setVal(int val)   
{   
    this->_mutex.lock();   
    this->_val = val;   
    this->_mutex.unlock();   
} 

De même, qu'est-ce que vous achetez? Si vous appelez setVal(-5) et setVal(17) à partir de threads séparés en même temps, quelle devrait être la valeur après avoir terminé tous les deux? Vous avez fait des efforts pour vous assurer que le premier à commencer est aussi le premier à finir, mais comment est-ce que cela aide à obtenir la «bonne» valeur?

Answer 4

Sur les plates-formes x86 32 bits, les lectures et les écritures de valeurs 32 bits alignées sur une limite de 4 octets sont atomiques. Sur les plates-formes 64 bits, vous pouvez également compter sur des charges 64 bits et des magasins de valeurs alignées sur 8 octets. Les processeurs SPARC et POWER fonctionnent également comme ça. C++ ne fait aucune garantie de ce genre, mais en pratique aucun compilateur ne va se tromper, puisque chaque programme multi-thread non trivial repose sur ce comportement.