946 Chapter 18: ConcurrencyAnthony

946 Chapter 18: Concurrency
Anthony is one of the world key experts on this topic, and this chapter would not have been possible
without him. Besides a preview of his book, he provided a first implementation of the standard
concurrency library (see [JustThread]), wrote several articles, and gave valuable feedback, which all
helped me to present this topic in what, hopefully, is a useful way. But in addition, I’d like to thank
a few other concurrency experts who helped me to write this chapter: Hans Boehm, Scott Meyers,
Bartosz Milewski, Lawrence Crowl, and Peter Sommerlad.
The chapter is organized as follows:
• First, I introduce various ways to start multiple threads. After both the high-level and the lowlevel
interfaces are introduced, details of starting a thread are presented.
• Section 18.4, page 982, offers a detailed discussion of the problem of synchronizing threads. The
main problem is concurrent data access.
• Finally, various features to synchronize threads and concurrent data access are discussed:
– Mutexes and locks (see Section 18.5, page 989), including call_once() (see Section 18.5.3,
page 1000)
– Condition variables (see Section 18.6, page 1003)
– Atomics (see Section 18.7, page 1012)
18.1 The High-Level Interface: async() and
Futures
For novices, the best starting point to run your program with multiple threads is the high-level interface
of the C++ standard library provided by std::async() and class std::future:
• async() provides an interface to let a piece of functionality, a callable object (see Section 4.4,
page 54), run in the background as a separate thread, if possible.
• Class future allows you to wait for the thread to be finished and provides access to its outcome:
return value or exception, if any.
This section introduces this high-level interface in detail, extended by an introduction to class
std::shared_future, which allows you to wait for and process the outcome of a thread at
multiple places.
18.1.1 A First Example Using async() and Futures
Suppose that we have to compute the sum of two operands returned by two function calls. The usual
way to program that would be as follows:
func1() + func2()
This means that the processing of the operands happens sequentially. The program will first call
func1() and then call func2() or the other way round (according to language rules, the order is
undefined). In both cases, the overall processing takes the duration of func1() plus the duration of
func2() plus computing the sum.

ผลลัพธ์ (ไทย) 1:

946 บท 18: เกิด
แอนโทนีเป็นหนึ่งในผู้เชี่ยวชาญหลักโลกในหัวข้อนี้ และบทนี้จะไม่ได้
ไม่ นอกจากตัวอย่างของหนังสือของเขา เขาให้ดำเนินการแรกมาตรฐาน
เกิดไลบรารี (ดู [JustThread]), เขียนบทความหลาย และให้คำติชมอันมีค่า ทั้งหมดที่
ช่วยในการนำเสนอหัวข้อนี้ในสิ่ง หวัง เป็นวิธีมีประโยชน์ แต่นอกจากนี้ ฉันอยากจะขอบคุณ
กี่อื่น ๆ เกิดผู้เชี่ยวชาญที่ช่วยในการเขียนบทนี้: ฮันส์ Boehm สก็อต Meyers,
Bartosz Milewski, Crowl ลอว์เรนซ์ และปีเตอร์ Sommerlad
บทการจัดระเบียบดัง:
•ก่อน ผมแนะนำหลากหลายวิธีในการเริ่มต้นหัวข้อหลาย หลังจากระดับสูงทั้ง lowlevel
อินเทอร์เฟซนำมาใช้ มีแสดงรายละเอียดของหัวข้อการเริ่มต้น
•ส่วน 18.4 หน้า 982 ให้อภิปรายรายละเอียดของปัญหาของหัวข้อการทำข้อมูลให้ตรงกัน
ปัญหาหลักคือ การเข้าถึงข้อมูลพร้อมกัน
•สุดท้าย ต่าง ๆ ลักษณะการซิงโครไนส์เธรด และเข้าถึงข้อมูลพร้อมกันจะ:
– Mutexes และ ล็อค (ดูส่วน 18.5 หน้า 989), รวมทั้ง call_once() (ดูส่วน 18.5.3,
page 1000)
– เงื่อนไขตัวแปร (ดูส่วน 18.6 หน้า 1003)
-Atomics (ดูส่วน 18.7 หน้า 1012)
18.1 High-Level ติดต่อ: async() และ
ล่วงหน้า
สามเณร จุดเริ่มต้นส่วนการเรียกใช้โปรแกรมของคุณ มีหลายหัวข้อมีอินเทอร์เฟซพื้นฐาน
ของรีมาตรฐาน C โดย<>std::future std::async() และชั้น:
• async() เป็นอินเทอร์เฟซเพื่อให้ชิ้นงาน วัตถุ callable (ดูส่วน 4.4,
หน้า 54), ใช้เป็นด้ายแยก ถ้าไป
•<>ในอนาคตชั้นให้คุณรอด้ายจะแล้วเสร็จ และถึงผล:
ส่งกลับค่าหรือข้อยกเว้น การ
ส่วนนี้แนะนำอินเทอร์เฟซนี้สูงในรายละเอียด ขยายแนะนำคลาส
std::shared_future <> ซึ่งช่วยให้คุณรอ และการประมวลผลผลลัพธ์ของเธรดที่
หลายสถาน.
18.1.1 A แรกตัวอย่างโดยใช้ async() และในอนาคต
สมมติว่า เราต้องคำนวณผลรวมของสองตัวถูกดำเนินการส่งกลับ โดยการเรียกฟังก์ชันที่สอง ปกติ
วิธีการโปรแกรมที่จะเป็นดังนี้:
func1() func2 ()
หมายความ ว่า การประมวลผลของตัวถูกดำเนินการเกิดขึ้นตามลำดับ โปรแกรมจะเรียกก่อน
func1() แล้วโทร func2() หรือวิธีอื่น ๆ รอบ (ตามกฎของภาษา ใบสั่งเป็น
ไม่ได้กำหนด) ในทั้งสองกรณี การประมวลผลโดยรวมใช้ระยะเวลา ของ func1() บวก of
func2() ระยะเวลาการคำนวณผลรวม

ผลลัพธ์ (ไทย) 2:

946 บทที่ 18: Concurrency
แอนโทนี่เป็นหนึ่งในโลกที่สำคัญผู้เชี่ยวชาญในหัวข้อนี้และบทนี้จะไม่ได้รับเป็นไปได้
โดยไม่มีเขา นอกจากนี้ตัวอย่างของหนังสือของเขาที่เขาให้การดำเนินการครั้งแรกของมาตรฐาน
ห้องสมุดพ้อง (ดู [JustThread]) เขียนบทความหลายและให้ข้อเสนอแนะที่มีคุณค่าที่ทุกคน
ช่วยให้ผมที่จะนำเสนอหัวข้อนี้ในสิ่งที่หวังว่าเป็นวิธีที่มีประโยชน์ . แต่ในนอกจากนี้ผมอยากจะขอบคุณ
ไม่กี่ผู้เชี่ยวชาญเห็นพ้องอื่น ๆ ที่ช่วยให้ผมเขียนบทนี้: ฮันส์ Boehm สกอตต์เมเยอร์ส
Bartosz Milewski อเรนซ์ Crowl และปีเตอร์ Sommerlad
บทที่มีการจัดดังนี้
•ครั้งแรกผม แนะนำวิธีการต่างๆที่จะเริ่มต้นหลายหัวข้อ หลังจากที่ทั้งระดับสูงและ lowlevel
อินเตอร์เฟซที่ได้รับการแนะนำให้รู้จักกับรายละเอียดของการเริ่มต้นด้ายนั้นจะมี
•มาตรา 18.4, หน้า 982 มีการอภิปรายรายละเอียดของปัญหาตรงกันหัวข้อ
ปัญหาหลักคือการเข้าถึงข้อมูลพร้อมกัน
•ในที่สุดคุณสมบัติต่างๆเพื่อประสานหัวข้อและการเข้าถึงข้อมูลพร้อมกันจะกล่าวถึง:
- mutexes และล็อค (ดูมาตรา 18.5, หน้า 989) รวมทั้ง call_once () (ดูมาตรา 18.5.3,
หน้า 1000)
- สภาพตัวแปร (ดูมาตรา 18.6, หน้า 1003)
- อะตอม (ดูมาตรา 18.7, หน้า 1012)
18.1 ระดับสูง Interface: async () และ
สัญญาซื้อขายล่วงหน้า
สำหรับสามเณรเป็นจุดเริ่มต้นที่ดีที่สุดเพื่อเรียกใช้โปรแกรมของคุณด้วยหลายหัวข้อที่อยู่ในระดับสูง อินเตอร์เฟซระดับ
ของห้องสมุด C + + มาตรฐานการให้บริการโดย std :: async () และมาตรฐานการเรียนในอนาคต :: <>:
• async () มีอินเตอร์เฟซเพื่อให้ชิ้นส่วนของการทำงานวัตถุ callable (ดูมาตรา 4.4,
หน้า 54) , ทำงานในพื้นหลังเป็นหัวข้อที่แยกต่างหากถ้าเป็นไปได้
ในอนาคต•คลาส <> ช่วยให้คุณสามารถที่จะรอให้ด้ายจะแล้วเสร็จและให้การเข้าถึงผลของมัน
ค่าตอบแทนหรือข้อยกเว้นถ้ามี
ในส่วนนี้จะนำเสนอในระดับสูงนี้ อินเตอร์เฟซในรายละเอียดขยายโดยการแนะนำไปเรียน
std :: shared_future <> ซึ่งช่วยให้คุณรอการประมวลผลและผลของด้ายที่
สถานที่ต่างๆ
18.1.1 การซื้อแรกตัวอย่างการใช้ async () และฟิวเจอร์ส
สมมติว่าเรามี การคำนวณผลรวมของทั้งสองตัวถูกดำเนินการส่งกลับโดยสองสายงาน ตามปกติ
วิธีการเขียนโปรแกรมที่จะเป็นดังนี้
func1 () + Func2 ()
ซึ่งหมายความว่าการประมวลผลของตัวถูกดำเนินการที่เกิดขึ้นตามลำดับ โปรแกรมแรกที่จะเรียก
func1 () แล้วโทร Func2 () หรือรอบทางอื่น ๆ (ตามกฎภาษาเพื่อที่จะ
ไม่ได้กำหนด) ในทั้งสองกรณีการประมวลผลโดยรวมจะใช้เวลาระยะเวลาของการ func1 () บวกกับระยะเวลาของการ
Func2 () บวกกับการคำนวณผลรวม

ผลลัพธ์ (ไทย) 3:

946 บทที่ 18 : การ
แอนโทนี่เป็นหนึ่งของโลกที่สำคัญผู้เชี่ยวชาญในหัวข้อนี้ และบทนี้จะไม่ได้รับเป็นไปได้
โดยไม่มีเขา นอกจากนี้ตัวอย่างของหนังสือของเขา เขาให้ใช้งานครั้งแรกของห้องสมุดการมาตรฐาน
( ดู [ justthread ] ) เขียนบทความหลายและให้ข้อเสนอแนะที่มีคุณค่า ซึ่งทั้งหมด
ช่วยเสนอหัวข้อนี้ในสิ่งที่หวัง เป็นวิธีที่มีประโยชน์แต่นอกจากนี้ผมอยากขอบคุณ
ไม่กี่อื่น ๆ ผู้เชี่ยวชาญด้านการ ที่ช่วยฉันเขียนบทนี้ : ฮันส์ โบม สก็อต ไมเยอร์
bartosz milewski ลอว์เรนซ์ crowl และปีเตอร์ sommerlad .
บทจัดดังนี้
- ครั้งแรกผมแนะนำวิธีการต่าง ๆเพื่อเริ่มต้นหลายกระทู้ หลังจากทั้งระดับสูงและระดับต่ำ
interfaces เปิดรายละเอียดของการเริ่มต้นหัวข้อได้แก่ส่วนค่าบริการ
- หน้า 982 , เสนอการอภิปรายรายละเอียดของปัญหาของการกระทู้
ปัญหาหลักคือการเข้าถึงข้อมูล .
- ในที่สุด คุณสมบัติต่าง ๆ เช่น หัวข้อ และการเข้าถึงข้อมูลการอภิปราย :
- mutexes และล็อค ( ดูมาตรา 18 หน้า 989 ) ได้แก่ call_once() ( ดูมาตรา 18.5.3

) , หน้า 1 ) ตัวแปรสภาวะ ( ดูมาตรา 18.6 , หน้า 1002 )
- อะตอม ( ดูมาตรา 18.7 , หน้า 1 )
18.1 ระดับอินเตอร์เฟซ : async()

และล่วงหน้าสำหรับสามเณรจุดเริ่มต้นที่ดีที่สุดเพื่อเรียกใช้โปรแกรมของคุณด้วยหลายกระทู้เป็นระดับสูงติดต่อ
ของมาตรฐานห้องสมุดโดย std : : async() และคลาส std : : < > :
- async() ในอนาคต มีอินเตอร์เฟซเพื่อให้ชิ้นส่วนของฟังก์ชันวัตถุคง ( ดูมาตรา 4.4
หน้า 54 )ทำงานในพื้นหลังเป็นหัวข้อแยกต่างหาก ถ้าเป็นไปได้
- คลาสในอนาคต < > ช่วยให้คุณรอด้ายจะแล้วเสร็จและมีการเข้าถึงผล :
คืนค่าหรือข้อยกเว้น ถ้าใด ๆ .
ส่วนนี้แนะนำอินเตอร์เฟซระดับสูงนี้ในรายละเอียด การแนะนำคลาส
std : : shared_future < > ซึ่งช่วยให้คุณรอและกระบวนการผลของกระทู้ที่
หลายแห่ง .
18.1.1 แรกและตัวอย่างการใช้ async() ล่วงหน้า
สมมติว่า เราต้องคำนวณผลรวมของ 2 เปอแรนด์ที่ส่งกลับโดยฟังก์ชันสองสาย วิธีปกติ
โปรแกรมจะเป็นดังนี้ func1() func2()

ซึ่งหมายความว่าการประมวลผลของเปอแรนด์เกิดขึ้นตามลำดับ . โปรแกรมจะเรียก
func1() แล้วโทร func2() หรือรอบทางอื่น ๆ ( ตามกฎ , ภาษาคำสั่ง
Prayer ) ในทั้งสองกรณี , การประมวลผลโดยรวมใช้ระยะเวลา func1() บวกระยะเวลา
func2() พลัสคำนวณผลรวม