Görünüşe göre, iş parçacıkları arasında paylaşılan bir değişkeni mutasyona uğratan kod, neden bir yarış durumundan zarar görmüyor?

Cygwin GCC kullanıyorum ve şu kodu çalıştırıyorum:

#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;
}

Çizgi ile Derleyen: g++ -Wall -fexceptions -g -std=c++14 -c main.cpp -o main.o.

Doğru olan 1000 yazdırır. Ancak, daha önce artırılmış bir değerin üzerine yazılan iş parçacıkları nedeniyle daha az bir sayı bekliyordum. Bu kod neden karşılıklı erişimden zarar görmüyor?

Test makinemde 4 çekirdek var ve bildiğim programa herhangi bir kısıtlama koymuyorum.

Paylaşılan içeriğin foodaha karmaşık bir şeyle değiştirilmesi durumunda sorun devam eder , örneğin

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

foo()o kadar kısadır ki, her iş parçacığı muhtemelen bir sonraki daha ortaya çıkmadan önce biter. Eğer rastgele bir süre için uyku eklerseniz foo()önce u++, size beklediğiniz görmeye başlayabilir.

Bir yarış koşulunun kodun yanlış çalışacağını garanti etmediğini, sadece tanımlanmamış bir davranış olduğu için her şeyi yapabileceğini anlamak önemlidir. Beklendiği gibi çalıştırma dahil.

Özellikle X86 ve AMD64 makinelerinde yarış koşulları, bazı durumlarda nadiren sorunlara neden olur, çünkü talimatların çoğu atomiktir ve tutarlılık garantileri çok yüksektir. Bu garantiler, birçok talimatın atomik olması için kilit önekinin gerekli olduğu çoklu işlemcili sistemlerde biraz azaltılır.

Makinenizdeki artış atomik bir işlem ise, bu, dil standardına göre Tanımsız Davranış olsa bile muhtemelen doğru şekilde çalışacaktır.

Spesifik olarak bu durumda kodun, tek işlemcili sistemlerde gerçekten atomik olan atomik bir Fetch and Add komutuna (X86 montajında ​​ADD veya XADD) derlenebileceğini umuyorum, ancak çok işlemcili sistemlerde bunun atomik ve kilit olması garanti edilmez bunu yapmak için gerekli olacaktır. Çok işlemcili bir sistem üzerinde çalışıyorsanız, iş parçacıklarının karışabileceği ve yanlış sonuçlar üretebileceği bir pencere olacaktır.

Özellikle ben montaj kullanarak kodunuzu derlenmiş https://godbolt.org/ ve foo()karşı derler:

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

Bu, yalnızca tek bir işlemci için atomik olacak bir ekleme talimatı gerçekleştirdiği anlamına gelir (yukarıda belirtildiği gibi çok işlemcili bir sistem için böyle değildir).

Daha önce ya da sonra uyumanızın pek bir şey olmadığını düşünüyorum u++. Daha ziyade, işlemin u++- çağıran iş parçacığı ek yüküne kıyasla foo- yakalanması pek olası olmayacak şekilde çok hızlı bir şekilde gerçekleştirilen koda dönüşmesidir. Ancak, operasyonu "uzatırsanız" u++, yarış durumu çok daha olası hale gelir:

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

sonuç: 694

BTW: Ben de denedim

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

ve bana çoğu kez verdi 1997, ama bazen 1995.

Bir yarış durumundan muzdarip. Put usleep(1000);önce u++;de fooben farklı çıkış (<1000) her zaman görüyoruz.

1. Yarış durumu olsa, sizin için apaçık niye muhtemel cevabı yok biri, yani foo()her iplik bitirir sonraki kutu bile başlamadan önce o, bir iş parçacığı başlatmak için gereken zaman ile karşılaştırıldığında, bu nedenle hızlı. Fakat...

2. Orijinal sürümünüzle bile, sonuç sisteme göre değişir: Bir (dört çekirdekli) Macbook'ta kendi yönteminizle denedim ve on seferde 1000, altı kez 999 ve bir kez 998 aldım. Yani yarış biraz nadir ama açıkça mevcut.

3. Sen derlenen '-g'böcek yok ederek bir yolu vardır ki,. Kodunuzu hala değişmeden ama değiştirmeden yeniden derledim '-g've yarış çok daha belirgin hale geldi: Bir kez 1000, üç kez 999, iki kez 998, iki kez 997, bir kez 996 ve bir kez 992 aldım.

4. Yeniden. bir uyku ekleme önerisi - bu yardımcı olur, ancak (a) sabit bir uyku süresi, iş parçacıkları başlangıç ​​zamanına göre hala çarpık kalır (zamanlayıcı çözünürlüğüne bağlı olarak) ve (b) rastgele bir uyku, istediğimiz şey olduğunda onları yayar onları birbirine yaklaştırın. Bunun yerine, onları bir başlangıç ​​sinyalini beklemeleri için kodlardım, böylece çalışmalarına izin vermeden önce hepsini oluşturabilirim. Bu sürümle ( '-g'olsun veya olmasın ), 974 kadar düşük ve 998'den yüksek olmayan sonuçları her yerde alıyorum:

   #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;
   }