Augmentez le filetage/les mutex, pourquoi cela fonctionne-t-il?

Question

code:

#include <iostream> 
#include "stdafx.h" 
#include <boost/thread.hpp> 
#include <boost/thread/mutex.hpp> 

using namespace std; 
boost::mutex mut; 
double results[10]; 

void doubler(int x) { 
//boost::mutex::scoped_lock lck(mut); 
results[x] = x*2; 
} 

int _tmain(int argc, _TCHAR* argv[]) 
{ 
boost::thread_group thds; 
for (int x = 10; x>0; x--) { 
    boost::thread *Thread = new boost::thread(&doubler, x); 
    thds.add_thread(Thread); 
} 

thds.join_all(); 

for (int x = 0; x<10; x++) { 
    cout << results[x] << endl; 
} 

return 0; 
} 

Sortie:

0 
2 
4 
6 
8 
10 
12 
14 
16 
18 
Press any key to continue . . . 

... Alors ma question est pourquoi cela fonctionne (pour autant que je peux dire, je l'ai couru environ 20 fois), la production de ce qui précède sortie, même avec le verrouillage commenté? Je pensais que l'idée générale était:

 
in each thread: 
calculate 2*x 
copy results to CPU register(s) 
store calculation in correct part of array 
copy results back to main(shared) memory 

Je pense que dans toutes les conditions, mais parfait, cela aurait pour résultat une partie de la matrice de résultats ayant 0 valeurs. Copie-t-il seulement le double requis du tableau dans un registre cpu? Ou est-ce juste trop court d'un calcul pour être préempté avant d'écrire le résultat en RAM? Merci.

Answer 1

L'affectation a une valeur lvalue de type double à gauche et cette valeur lvalue est le seul objet auquel accède un thread. Puisque chaque thread accède à un objet différent, il n'y a pas de course de données.

Notez que l'inscription d'un tableau ne constitue pas un accès.

Answer 2

Cela fonctionne en raison de la ligne thds.join_all();. Le thread d'exécution principal retient ici jusqu'à ce que tous les autres threads soient terminés, puis continue à imprimer le tableau. Par conséquent, vous savez que toutes les valeurs de tableau ont été stockées avant de les imprimer. Si vous commentez cette ligne, vous obtiendrez des résultats imprévisibles.