Mengapa kode yang mengubah variabel bersama di seluruh utas ternyata TIDAK mengalami kondisi balapan?

Saya menggunakan Cygwin GCC dan menjalankan kode ini:

#include <iostream>
#include <thread>
#include <vector>
using namespace std;

unsigned u = 0;

void foo()
{
    u++;
}

int main()
{
    vector<thread> threads;
    for(int i = 0; i < 1000; i++) {
        threads.push_back (thread (foo));
    }
    for (auto& t : threads) t.join();

    cout << u << endl;
    return 0;
}

Disusun dengan baris: g++ -Wall -fexceptions -g -std=c++14 -c main.cpp -o main.o.

Ini mencetak 1000, yang benar. Namun, saya mengharapkan jumlah yang lebih rendah karena utas menimpa nilai yang sebelumnya bertambah. Mengapa kode ini tidak saling akses?

Mesin uji saya memiliki 4 inti, dan saya tidak membatasi program yang saya ketahui.

Masalah tetap ada saat mengganti konten yang dibagikan foodengan sesuatu yang lebih kompleks, misalnya

if (u % 3 == 0) {
    u += 4;
} else {
    u -= 1;
}

foo()sangat pendek sehingga setiap utas mungkin selesai bahkan sebelum utas berikutnya muncul. Jika Anda menambahkan tidur untuk waktu acak foo()sebelum u++, Anda mungkin mulai melihat apa yang Anda harapkan.

Penting untuk dipahami bahwa kondisi balapan tidak menjamin kode akan berjalan dengan tidak benar, hanya dapat melakukan apa saja, karena ini adalah perilaku yang tidak ditentukan. Termasuk berjalan seperti yang diharapkan.

Khususnya pada mesin X86 dan AMD64, kondisi balapan dalam beberapa kasus jarang menyebabkan masalah karena banyak instruksi bersifat atom dan jaminan koherensi sangat tinggi. Jaminan ini agak berkurang pada sistem multi prosesor di mana awalan kunci diperlukan untuk banyak instruksi menjadi atom.

Jika peningkatan mesin Anda adalah operasi atomik, ini kemungkinan akan berjalan dengan benar meskipun menurut standar bahasa itu adalah Perilaku yang Tidak Ditentukan.

Secara khusus saya berharap dalam kasus ini kode dapat dikompilasi ke instruksi Ambil dan Tambahkan atom (ADD atau XADD dalam perakitan X86) yang memang atom dalam sistem prosesor tunggal, namun pada sistem multiprosesor ini tidak dijamin menjadi atom dan kunci akan diminta untuk membuatnya seperti itu. Jika Anda menjalankan sistem multiprosesor akan ada jendela di mana utas dapat mengganggu dan menghasilkan hasil yang salah.

Secara khusus saya menyusun kode Anda untuk perakitan menggunakan https://godbolt.org/ dan foo()mengkompilasi ke:

foo():
        add     DWORD PTR u[rip], 1
        ret

Ini berarti ia hanya melakukan instruksi penambahan yang untuk satu prosesor akan menjadi atom (meskipun seperti yang disebutkan di atas tidak demikian untuk sistem multi prosesor).

Saya pikir tidak apa-apa jika Anda tidur sebelum atau sesudah u++. Ini bukan operasi yang u++diterjemahkan menjadi kode yang - dibandingkan dengan overhead utas pemijahan yang memanggil foo- dilakukan dengan sangat cepat sehingga tidak mungkin dicegat. Namun, jika Anda "memperpanjang" operasi u++, kondisi balapan akan menjadi lebih mungkin:

void foo()
{
    unsigned i = u;
    for (int s=0;s<10000;s++);
    u = i+1;
}

hasil: 694

BTW: Saya juga mencoba

if (u % 2) {
    u += 2;
} else {
    u -= 1;
}

dan itu memberi saya lebih banyak waktu 1997, tetapi terkadang 1995.

Itu memang menderita kondisi ras. Masukan usleep(1000);sebelum u++;di foodan saya melihat output yang berbeda (<1000) setiap kali.

1. Jawaban yang mungkin mengapa kondisi balapan tidak terwujud untuk Anda, meskipun memang ada, adalah foo()begitu cepat, dibandingkan dengan waktu yang diperlukan untuk memulai utas, sehingga setiap utas selesai bahkan sebelum utas berikutnya dapat dimulai. Tapi...

2. Bahkan dengan versi asli Anda, hasilnya bervariasi berdasarkan sistem: Saya mencobanya dengan cara Anda pada Macbook (quad-core), dan dalam sepuluh kali proses, saya mendapatkan 1000 tiga kali, 999 enam kali, dan 998 kali. Jadi perlombaan agak jarang, tapi jelas ada.

3. Anda mengompilasi dengan '-g', yang memiliki cara untuk menghilangkan bug. Saya mengkompilasi ulang kode Anda, masih tidak berubah tetapi tanpa '-g', dan balapan menjadi jauh lebih jelas: Saya mendapat 1000 sekali, 999 tiga kali, 998 dua kali, 997 dua kali, 996 sekali, dan 992 sekali.

4. Kembali. saran untuk menambahkan tidur - itu membantu, tetapi (a) waktu tidur tetap membuat utas masih miring oleh waktu mulai (tergantung pada resolusi pengatur waktu), dan (b) tidur acak menyebarkannya ketika apa yang kita inginkan adalah tarik mereka lebih dekat. Sebagai gantinya, saya akan mengkodekan mereka untuk menunggu sinyal mulai, jadi saya bisa membuat semuanya sebelum membiarkan mereka mulai bekerja. Dengan versi ini (dengan atau tanpa '-g'), saya mendapatkan hasil di semua tempat, serendah 974, dan tidak lebih tinggi dari 998:

   #include <iostream>
   #include <thread>
   #include <vector>
   using namespace std;
   
   unsigned u = 0;
   bool start = false;
   
   void foo()
   {
       while (!start) {
           std::this_thread::yield();
       }
       u++;
   }
   
   int main()
   {
       vector<thread> threads;
       for(int i = 0; i < 1000; i++) {
           threads.push_back (thread (foo));
       }
       start = true;
       for (auto& t : threads) t.join();
   
       cout << u << endl;
       return 0;
   }