เหตุใดโค้ดที่กลายพันธุ์ของตัวแปรที่ใช้ร่วมกันระหว่างเธรดจึงไม่ได้รับผลกระทบจากสภาวะการแข่งขัน

ฉันใช้ Cygwin GCC และเรียกใช้รหัสนี้:

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

g++ -Wall -fexceptions -g -std=c++14 -c main.cpp -o main.oรวบรวมกับเส้น:

มันพิมพ์ 1,000 ซึ่งถูกต้อง อย่างไรก็ตามฉันคาดว่าจะมีจำนวนน้อยกว่าเนื่องจากเธรดเขียนทับค่าที่เพิ่มขึ้นก่อนหน้านี้ เหตุใดรหัสนี้จึงไม่ได้รับผลกระทบจากการเข้าถึงซึ่งกันและกัน

เครื่องทดสอบของฉันมี 4 คอร์และฉันไม่มีข้อ จำกัด ในโปรแกรมที่ฉันรู้จัก

ปัญหายังคงมีอยู่เมื่อเปลี่ยนเนื้อหาของการแชร์fooด้วยสิ่งที่ซับซ้อนกว่าเช่น

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

foo()สั้นมากจนแต่ละเธรดอาจจะเสร็จสิ้นก่อนที่เธรดถัดไปจะเกิด หากคุณเพิ่มการนอนหลับเป็นเวลาสุ่มfoo()ก่อนหน้าu++นั้นคุณอาจเริ่มเห็นสิ่งที่คุณคาดหวัง

สิ่งสำคัญคือต้องเข้าใจสภาพการแข่งขันไม่ได้รับประกันว่าโค้ดจะทำงานไม่ถูกต้องเพียง แต่สามารถทำอะไรก็ได้เนื่องจากเป็นพฤติกรรมที่ไม่ได้กำหนดไว้ รวมถึงการวิ่งตามที่คาดหวัง.

โดยเฉพาะอย่างยิ่งในสภาพการแข่งขันของเครื่อง X86 และ AMD64 ในบางกรณีแทบจะไม่ก่อให้เกิดปัญหาเนื่องจากคำแนะนำส่วนใหญ่เป็นแบบอะตอมและการรับประกันการเชื่อมโยงกันนั้นสูงมาก การรับประกันเหล่านี้ค่อนข้างลดลงในระบบประมวลผลหลายตัวซึ่งจำเป็นต้องใช้คำนำหน้าล็อคเพื่อให้คำแนะนำหลาย ๆ อย่างเป็นแบบอะตอม

หากการเพิ่มขึ้นของเครื่องของคุณเป็นแบบอะตอมสิ่งนี้จะทำงานได้อย่างถูกต้องแม้ว่าตามมาตรฐานภาษาจะเป็นพฤติกรรมที่ไม่ได้กำหนด

โดยเฉพาะอย่างยิ่งฉันคาดหวังว่าในกรณีนี้รหัสอาจถูกคอมไพล์ไปยัง atomic Fetch and Addคำสั่ง (ADD หรือ XADD ในชุดประกอบ X86) ซึ่งแน่นอนว่าเป็นอะตอมในระบบโปรเซสเซอร์เดี่ยวอย่างไรก็ตามในระบบมัลติโปรเซสเซอร์ไม่รับประกันว่าจะเป็นอะตอมและตัวล็อค จะต้องทำเช่นนั้น หากคุณกำลังรันบนระบบมัลติโปรเซสเซอร์จะมีหน้าต่างที่เธรดอาจรบกวนและให้ผลลัพธ์ที่ไม่ถูกต้อง

โดยเฉพาะฉันรวบรวมรหัสของคุณเพื่อประกอบโดยใช้https://godbolt.org/และfoo()รวบรวมไปที่:

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

ซึ่งหมายความว่ามันกำลังดำเนินการคำสั่งเพิ่มซึ่งสำหรับโปรเซสเซอร์ตัวเดียวจะเป็นแบบอะตอม (แม้ว่าตามที่กล่าวไว้ข้างต้นจะไม่ใช่สำหรับระบบมัลติโปรเซสเซอร์)

u++ฉันคิดว่ามันเป็นไม่มากสิ่งที่ถ้าคุณใส่นอนหลับก่อนหรือหลัง ค่อนข้างที่การดำเนินการu++จะแปลเป็นรหัสที่เทียบกับค่าใช้จ่ายของเธรดการวางไข่ที่เรียกใช้foo- ดำเนินการอย่างรวดเร็วมากจนไม่น่าจะถูกดักฟัง อย่างไรก็ตามหากคุณ "ยืดเวลา" การดำเนินu++การสภาพการแข่งขันจะมีแนวโน้มมากขึ้น:

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

ผลลัพธ์: 694

BTW: ฉันลองแล้วด้วย

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

และมันทำให้ผมมีเวลาส่วนใหญ่แต่บางครั้ง19971995

มันต้องทนทุกข์ทรมานจากสภาพการแข่งขัน ใส่usleep(1000);ก่อนu++;ในfooและฉันเห็นผลลัพธ์ที่แตกต่างกัน (<1000) ในแต่ละครั้ง

1. คำตอบที่เป็นไปได้ว่าทำไมสภาพการแข่งขันจึงไม่ปรากฏให้คุณเห็นแม้ว่าจะมีอยู่จริง แต่ก็foo()เร็วมากเมื่อเทียบกับเวลาที่ใช้ในการเริ่มเธรดซึ่งแต่ละเธรดจะเสร็จสิ้นก่อนที่จะเริ่มต้นครั้งต่อไป แต่...

2. แม้จะเป็นเวอร์ชันดั้งเดิมของคุณผลลัพธ์ก็จะแตกต่างกันไปตามระบบ: ฉันลองใช้ Macbook (ควอดคอร์) ในแบบของคุณและในการวิ่ง 10 ครั้งฉันได้รับ 1,000 ครั้งสามครั้ง 999 หกครั้งและ 998 ครั้ง ดังนั้นการแข่งขันจึงค่อนข้างหายาก แต่มีอยู่อย่างชัดเจน

3. คุณรวบรวมด้วย'-g'ซึ่งมีวิธีทำให้จุดบกพร่องหายไป ฉันคอมไพล์โค้ดของคุณอีกครั้งยังคงไม่เปลี่ยนแปลง แต่ไม่มีไฟล์'-g'แข่งขันและการแข่งขันก็เด่นชัดขึ้นมาก: ฉันได้รับ 1,000 ครั้ง, 999 สามครั้ง, 998 สองครั้ง, 997 สองครั้ง, 996 ครั้งและ 992 ครั้ง

4. เรื่อง ข้อเสนอแนะในการเพิ่มการนอนหลับซึ่งช่วยได้ แต่ (ก) เวลาพักเครื่องคงที่ทำให้เธรดยังคงเบ้ตามเวลาเริ่มต้น (ขึ้นอยู่กับความละเอียดของตัวจับเวลา) และ (ข) การนอนหลับแบบสุ่มจะกระจายออกไปเมื่อสิ่งที่เราต้องการคือ ดึงพวกเขาเข้ามาใกล้กัน แต่ฉันจะเขียนโค้ดให้พวกเขารอสัญญาณเริ่มต้นดังนั้นฉันจึงสามารถสร้างมันทั้งหมดก่อนที่จะให้พวกเขาทำงาน ด้วยเวอร์ชันนี้ (มีหรือไม่มี'-g') ฉันได้ผลลัพธ์ทุกที่ต่ำถึง 974 และไม่สูงกว่า 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;
   }