Tại sao mã thay đổi một biến được chia sẻ trên các chuỗi dường như KHÔNG bị điều kiện chủng tộc?

Tôi đang sử dụng Cygwin GCC và chạy mã này:

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

Biên soạn với dòng: g++ -Wall -fexceptions -g -std=c++14 -c main.cpp -o main.o.

Nó in 1000, đó là chính xác. Tuy nhiên, tôi mong đợi một số lượng ít hơn do các luồng ghi đè lên một giá trị đã tăng trước đó. Tại sao mã này không bị truy cập lẫn nhau?

Máy thử nghiệm của tôi có 4 lõi và tôi không đặt bất kỳ hạn chế nào đối với chương trình mà tôi biết.

Sự cố vẫn tiếp diễn khi thay thế nội dung được chia sẻ foobằng nội dung phức tạp hơn, ví dụ:

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

foo()quá ngắn nên mỗi luồng có thể kết thúc trước khi luồng tiếp theo được tạo ra. Nếu bạn thêm một giấc ngủ vào một khoảng thời gian ngẫu nhiên foo()trước đó u++, bạn có thể bắt đầu thấy những gì bạn mong đợi.

Điều quan trọng là phải hiểu một điều kiện chủng tộc không đảm bảo mã sẽ chạy không chính xác, chỉ đơn thuần là nó có thể làm bất cứ điều gì, vì nó là một hành vi không xác định. Bao gồm cả việc chạy như mong đợi.

Đặc biệt trên các máy X86 và AMD64, các điều kiện chạy đua trong một số trường hợp hiếm khi gây ra vấn đề vì nhiều lệnh là nguyên tử và đảm bảo đồng tiền rất cao. Những đảm bảo này phần nào bị giảm bớt trên các hệ thống đa bộ xử lý nơi cần tiền tố khóa để nhiều lệnh trở thành nguyên tử.

Nếu gia số trên máy của bạn là op nguyên tử, điều này có thể sẽ chạy chính xác mặc dù theo tiêu chuẩn ngôn ngữ, đó là Hành vi không xác định.

Cụ thể, tôi mong đợi trong trường hợp này, mã có thể được biên dịch thành lệnh Tìm nạp và Thêm nguyên tử (ADD hoặc XADD trong hợp ngữ X86) thực sự là nguyên tử trong các hệ thống bộ xử lý đơn lẻ, tuy nhiên trên các hệ thống đa xử lý, điều này không được đảm bảo là nguyên tử và khóa sẽ được yêu cầu để làm cho nó như vậy. Nếu bạn đang chạy trên một hệ thống đa xử lý, sẽ có một cửa sổ nơi các luồng có thể can thiệp và tạo ra kết quả không chính xác.

Cụ thể, tôi đã biên dịch mã của bạn thành assembly bằng https://godbolt.org/ và foo()biên dịch thành:

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

Điều này có nghĩa là nó chỉ thực hiện một lệnh bổ sung đối với một bộ xử lý đơn lẻ sẽ là nguyên tử (mặc dù như đã đề cập ở trên không phải như vậy đối với hệ thống nhiều bộ xử lý).

Tôi nghĩ rằng nó không phải là quá nhiều điều nếu bạn đặt một giấc ngủ trước hoặc sau u++. Đúng hơn là hoạt động u++chuyển thành mã - so với chi phí của các luồng sinh sản gọi foo- được thực hiện rất nhanh chóng đến mức nó không có khả năng bị chặn. Tuy nhiên, nếu bạn "kéo dài" hoạt động u++, thì tình trạng cuộc đua sẽ trở nên nhiều khả năng:

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

kết quả: 694

BTW: Tôi cũng đã thử

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

và nó đã cho tôi hầu hết các lần 1997, nhưng đôi khi 1995.

Nó phải chịu một tình trạng chủng tộc. Đặt usleep(1000);trước u++;vào foovà tôi thấy đầu ra khác nhau (<1000) mỗi lần.

1. Câu trả lời có khả năng lý do tại sao tình trạng chủng tộc không biểu hiện cho bạn, mặc dù nó không tồn tại, đó là foo()rất nhanh, so với thời gian cần thiết để bắt đầu một chủ đề, mỗi chủ đề kết thúc trước khi lon tiếp theo thậm chí bắt đầu. Nhưng...

2. Ngay cả với phiên bản gốc của bạn, kết quả khác nhau tùy theo hệ thống: Tôi đã thử theo cách của bạn trên Macbook (lõi tứ) và trong mười lần chạy, tôi nhận được 1000 ba lần, 999 sáu lần và 998 một lần. Vì vậy, cuộc đua là hơi hiếm, nhưng hiện diện rõ ràng.

3. Bạn đã biên dịch với '-g', có cách làm cho lỗi biến mất. Tôi đã biên dịch lại mã của bạn, vẫn không thay đổi nhưng không có '-g', và cuộc đua trở nên rõ rệt hơn nhiều: Tôi nhận được 1000 một lần, 999 ba lần, 998 hai lần, 997 hai lần, 996 một lần và 992 một lần.

4. Re. gợi ý về việc thêm chế độ ngủ - điều đó sẽ hữu ích, nhưng (a) thời gian ngủ cố định khiến các chuỗi vẫn bị lệch theo thời gian bắt đầu (tùy thuộc vào độ phân giải của bộ đếm thời gian) và (b) chế độ ngủ ngẫu nhiên sẽ trải chúng ra khi những gì chúng ta muốn kéo chúng lại gần nhau hơn. Thay vào đó, tôi sẽ viết mã chúng để chờ tín hiệu bắt đầu, vì vậy tôi có thể tạo tất cả chúng trước khi để chúng hoạt động. Với phiên bản này (có hoặc không '-g'), tôi nhận được kết quả ở khắp nơi, thấp nhất là 974 và không cao hơn 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;
   }