ทำความเข้าใจกับ Std: Shared_mutex จาก C ++ 17

ทำความเข้าใจกับ std::shared_mutex จาก C ++ 17

std::shared_mutex เปิดตัวใน C ++ 17 เป็นการซิงโครไนซ์แบบดั้งเดิมที่อนุญาตให้หลายเธรดเก็บล็อคที่ใช้ร่วมกัน (อ่าน) พร้อมกันในขณะที่รับประกันการเข้าถึงพิเศษสำหรับการดำเนินการเขียน ช่วยแก้ปัญหาการทำงานพร้อมกันที่พบบ่อยที่สุดใน C++ ยุคใหม่ โดยให้นักพัฒนามีวิธีที่เป็นมาตรฐานและสะอาดตาในการล็อกตัวอ่านและผู้เขียนโดยไม่ต้องเข้าถึงไลบรารีของบริษัทอื่นหรือ API เฉพาะแพลตฟอร์ม

std::shared_mutex คืออะไรและเหตุใดจึงถูกเพิ่มใน C ++ 17

ก่อน C++17 นักพัฒนาที่ต้องการซีแมนทิกส์ของตัวอ่านและผู้เขียนจะต้องพึ่งพาโซลูชันเฉพาะแพลตฟอร์ม เช่น pthread_rwlock_t บนระบบ POSIX หรือ SRWLOCK บน Windows ไม่เช่นนั้นพวกเขาจะใช้ไลบรารีของบริษัทอื่น เช่น Boost คณะกรรมการมาตรฐาน C++17 ตระหนักถึงช่องว่างนี้และแนะนำ std::shared_mutex ในส่วนหัว เพื่อแก้ไขโดยตรง

แนวคิดหลักนั้นตรงไปตรงมา: ในหลายโปรแกรมในโลกแห่งความเป็นจริง ข้อมูลจะถูกอ่านบ่อยกว่าที่เขียนไว้มาก มาตรฐาน std::mutex ทำให้การเข้าถึงทั้งหมดเป็นอนุกรม - รวมการอ่าน - ซึ่งทำให้เกิดปัญหาคอขวดที่ไม่จำเป็น std::shared_mutex ยกเลิกข้อจำกัดนั้นโดยแยกความแตกต่างระหว่างโหมดการล็อคสองโหมด:

ล็อคที่ใช้ร่วมกัน (อ่าน) - ได้มาจาก lock_shared(); เธรดหลายตัวสามารถเก็บสิ่งนี้ไว้พร้อมกันได้ ทำให้เหมาะสำหรับการอ่านพร้อมกัน

ล็อคพิเศษ (เขียน) - ได้มาจากล็อค (); มีเพียงเธรดเดียวเท่านั้นที่สามารถเก็บสิ่งนี้ได้ในแต่ละครั้ง และไม่อนุญาตให้ใช้ล็อคร่วมกันในขณะที่มันถูกระงับ

std::shared_lock — wrapper RAII ที่เรียก lock_shared() ในการก่อสร้างและ Unlock_shared() เมื่อถูกทำลาย เพื่อป้องกันการรั่วไหลของทรัพยากร

std::unique_lock / std::lock_guard — ใช้กับโหมดเอกสิทธิ์เฉพาะบุคคล เพื่อให้มั่นใจว่าการดำเนินการเขียนได้รับการปกป้องอย่างสมบูรณ์และปลอดภัยต่อข้อยกเว้น

การออกแบบโหมดคู่นี้ทำให้ std::shared_mutex เหมาะอย่างยิ่งสำหรับสถานการณ์ต่างๆ เช่น แคช รีจิสทรีการกำหนดค่า และโครงสร้างข้อมูลใดๆ ที่การอ่านครอบงำเวิร์กโหลด

คุณใช้ std::shared_mutex ในโค้ดจริงพร้อมความคิดเห็นอย่างไร

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

#รวม

#รวม

#รวม

คลาส ConfigRegistry {

มาตรฐานที่ไม่แน่นอน :: shared_mutex mtx_; // ป้องกันแผนที่ด้านล่าง

std::unordered_map data_;

สาธารณะ:

// เส้นทางการอ่าน: หลายเธรดอาจเรียกสิ่งนี้พร้อมกัน

std::string รับ (const std::string& คีย์) const {

มาตรฐาน :: shared_lock ล็อค (mtx_); // ล็อคที่ใช้ร่วมกัน — ปลอดภัยสำหรับการอ่านพร้อมกัน

อัตโนมัติ = data_.find (คีย์);

ส่งคืน != data_.end() ? มัน -> วินาที : "";

}

// เขียนเส้นทาง: จำเป็นต้องเข้าถึงแบบเอกสิทธิ์เฉพาะบุคคล

ชุดโมฆะ (const std::string& key, const std::string& val) {

มาตรฐาน::unique_lock ล็อค(mtx_); // ล็อคพิเศษ - บล็อกผู้อ่านทั้งหมด

ข้อมูล_[คีย์] = วาล;

}

};

สังเกตว่าความคิดเห็นอธิบายเจตนาเบื้องหลังตัวเลือกการล็อคแต่ละรายการอย่างไร แทนที่จะแค่ย้ำว่าโค้ดทำอะไร นี่คือมาตรฐานทองคำ: ความคิดเห็นควรตอบว่าทำไม ไม่ใช่อะไร คีย์เวิร์ดที่ไม่แน่นอนบน mutex ช่วยให้สามารถประกาศ get() ได้ const ในขณะที่ยังสามารถล็อคได้ ซึ่งเป็นรูปแบบทั่วไปและเป็นสำนวน

ข้อมูลเชิงลึกที่สำคัญ: ใช้ RAII lock wrapper เสมอ (std::shared_lock, std::unique_lock) กับ std::shared_mutex — ไม่ต้องโทร lock() และ Unlock() ด้วยตนเอง การล็อกด้วยตนเองเมื่อมีข้อยกเว้นเป็นเส้นทางที่รับประกันว่าจะเกิดการชะงักงันและลักษณะการทำงานที่ไม่ได้กำหนดไว้

อะไรคือข้อผิดพลาดทั่วไปเมื่อทำงานกับ std::shared_mutex

แม้จะมีความคิดเห็นที่ชัดเจนและความตั้งใจที่ดี std::shared_mutex ก็มีกับดักที่ละเอียดอ่อนที่ทำให้นักพัฒนาที่มีประสบการณ์สะดุด สิ่งที่อันตรายที่สุดคือการอัพเกรดล็อค: ไม่มีวิธีในตัวที่จะอัพเกรดล็อคที่ใช้ร่วมกันเป็นล็อคพิเศษโดยไม่ต้องปล่อยออกก่อน พยายามที่จะทำเช่นนั้นโดยไม่ต้องทำซ้ำ

Related Posts

• เครื่องมือแซนด์บ็อกซ์บรรทัดคำสั่งที่รู้จักกันน้อยของ macOS (2025)
• ผู้บริหาร Waymo เผยบริษัทจ้างพนักงานระยะไกลในฟิลิปปินส์
• LED เข้าสู่ระดับนาโน แต่อุปสรรคด้านประสิทธิภาพยังท้าทาย LED ที่เล็กที่สุด
• ระบบควบคุมภาพ Sony Jumbotron (1998) [pdf]