- ข้อความ
- ประวัติศาสตร์
1016 Chapter 18: ConcurrencyThe sto
1016 Chapter 18: Concurrency
The store() operation performs a so-called release operation on the affected memory location,
which by default ensures that all prior memory operations, whether atomic or not, become visible to
other threads before the effect of the store operation.
Accordingly, thread consumer() performs a loop of load()s and processes data then:
while (!readyFlag.load()) { // loop until ready
...
}
std::cout store(desired);
return true;
}
else {
expected = this->load();
return false;
}
}
Thus, if the value had been updated by another thread in the meantime, it returns false with the
new value in expected.
The weak form may spuriously fail so that it returns false even when the expected value is
present. But the weak form is sometimes more efficient than the strong version.
www.it-ebooks.info
18.7 Atomics 1019
18.7.3 The C-Style Interface of Atomics
For the atomic proposal for C++, there was a corresponding proposal for C, which should provide
the same semantics but could, of course, not use such specific C++ features as templates, references,
and member functions. Therefore, the whole atomic interface has a C-style equivalent, which also
was proposed as an extension to the C standard.
For example, you can also declare an atomic as atomic_bool, and instead of store()
and load(), you can use global functions, which use a pointer to the object:
std::atomic_bool ab; // equivalent to: std::atomic ab
std::atomic_init(&ab,false); // see Section 18.7.1, page 1013
...
std::atomic_store(&ab,true); // equivalent to: ab.store(true)
...
if (std::atomic_load(&ab)) { // equivalent to: if (ab.load())
...
}
However, C added another interface, using _Atomic and _Atomic(), so the C-style interface in
general is useful only for code that needs to be both C and C++ compilable in the nearer term.
However, using the C-style atomic types is pretty common in C++. Table 18.12 lists the most important
atomic type names. There are more provided for less common types, such as
atomic_int_fast32_t for atomic.
Note that for shared pointers (see Section 5.2.1, page 76) special atomic operations are provided.
The reason is that a declaration, such as atomic, is not possible, because a shared
pointer is not trivially copyable. The atomic operations follow the naming conventions of the C-style
interface. See Section 5.2.4, page 96, for details.
18.7.4 The Low-Level Interface of Atomics
The low-level interface of atomics means using the atomic operations in a way that we have no
guaranteed sequential consistency. Thus, compilers and hardware might (partially) reorder access
on atomics (see Section 18.4.3, page 986).
Beware again: Although I give an example, this area is a minefield. You need a lot of expertise to
know when memory reorderings are worth the effort, and even experts often make mistakes in this
area.27
An expert using this feature should be familiar with the material mentioned in [N2480:MemMod]
and [BoehmAdve:MemMod] or, in general, all material listed at [Boehm:C++MM].
27 Special thanks to Hans Boehm and Bartosz Milewski for their support in letting me understand this and their
help in providing the right wording. Any flaws are my fault.
www.it-ebooks.info
1020 Chapter 18: Concurrency
Named Type Corresponding Type
atomic_bool atomic
atomic_char atomic
atomic_schar atomic
atomic_uchar atomic
atomic_short atomic
atomic_ushort atomic
atomic_int atomic
atomic_uint atomic
atomic_long atomic
atomic_ulong atomic
atomic_llong atomic
atomic_ullong atomic
atomic_char16_t atomic
atomic_char32_t atomic
atomic_wchar_t atomic
atomic_intptr_t atomic
atomic_uintptr_t atomic
atomic_size_t atomic
atomic_ptrdiff_t atomic
atomic_intmax_t atomic
atomic_uintmax_t atomic
Table 18.12. Some Named Types of std::atomic
An Example for the Low-Level Interface of Atomics
Consider the second example for using atomics, introduced in Section 18.7.1, page 1014, where we
declared an atomic flag to control access to some data:
long data;
std::atomic readyFlag(false);
and a thread providing the data:
data = 42; // provide some data
readyFlag.store(true); // and signal readiness
and a thread consuming the data:
while (!readyFlag.load()) { // loop until ready
...
}
std::cout
The store() operation performs a so-called release operation on the affected memory location,
which by default ensures that all prior memory operations, whether atomic or not, become visible to
other threads before the effect of the store operation.
Accordingly, thread consumer() performs a loop of load()s and processes data then:
while (!readyFlag.load()) { // loop until ready
...
}
std::cout store(desired);
return true;
}
else {
expected = this->load();
return false;
}
}
Thus, if the value had been updated by another thread in the meantime, it returns false with the
new value in expected.
The weak form may spuriously fail so that it returns false even when the expected value is
present. But the weak form is sometimes more efficient than the strong version.
www.it-ebooks.info
18.7 Atomics 1019
18.7.3 The C-Style Interface of Atomics
For the atomic proposal for C++, there was a corresponding proposal for C, which should provide
the same semantics but could, of course, not use such specific C++ features as templates, references,
and member functions. Therefore, the whole atomic interface has a C-style equivalent, which also
was proposed as an extension to the C standard.
For example, you can also declare an atomic as atomic_bool, and instead of store()
and load(), you can use global functions, which use a pointer to the object:
std::atomic_bool ab; // equivalent to: std::atomic ab
std::atomic_init(&ab,false); // see Section 18.7.1, page 1013
...
std::atomic_store(&ab,true); // equivalent to: ab.store(true)
...
if (std::atomic_load(&ab)) { // equivalent to: if (ab.load())
...
}
However, C added another interface, using _Atomic and _Atomic(), so the C-style interface in
general is useful only for code that needs to be both C and C++ compilable in the nearer term.
However, using the C-style atomic types is pretty common in C++. Table 18.12 lists the most important
atomic type names. There are more provided for less common types, such as
atomic_int_fast32_t for atomic.
Note that for shared pointers (see Section 5.2.1, page 76) special atomic operations are provided.
The reason is that a declaration, such as atomic, is not possible, because a shared
pointer is not trivially copyable. The atomic operations follow the naming conventions of the C-style
interface. See Section 5.2.4, page 96, for details.
18.7.4 The Low-Level Interface of Atomics
The low-level interface of atomics means using the atomic operations in a way that we have no
guaranteed sequential consistency. Thus, compilers and hardware might (partially) reorder access
on atomics (see Section 18.4.3, page 986).
Beware again: Although I give an example, this area is a minefield. You need a lot of expertise to
know when memory reorderings are worth the effort, and even experts often make mistakes in this
area.27
An expert using this feature should be familiar with the material mentioned in [N2480:MemMod]
and [BoehmAdve:MemMod] or, in general, all material listed at [Boehm:C++MM].
27 Special thanks to Hans Boehm and Bartosz Milewski for their support in letting me understand this and their
help in providing the right wording. Any flaws are my fault.
www.it-ebooks.info
1020 Chapter 18: Concurrency
Named Type Corresponding Type
atomic_bool atomic
atomic_char atomic
atomic_schar atomic
atomic_uchar atomic
atomic_short atomic
atomic_ushort atomic
atomic_int atomic
atomic_uint atomic
atomic_long atomic
atomic_ulong atomic
atomic_llong atomic
atomic_ullong atomic
atomic_char16_t atomic
atomic_char32_t atomic
atomic_wchar_t atomic
atomic_intptr_t atomic
atomic_uintptr_t atomic
atomic_size_t atomic
atomic_ptrdiff_t atomic
atomic_intmax_t atomic
atomic_uintmax_t atomic
Table 18.12. Some Named Types of std::atomic
An Example for the Low-Level Interface of Atomics
Consider the second example for using atomics, introduced in Section 18.7.1, page 1014, where we
declared an atomic flag to control access to some data:
long data;
std::atomic readyFlag(false);
and a thread providing the data:
data = 42; // provide some data
readyFlag.store(true); // and signal readiness
and a thread consuming the data:
while (!readyFlag.load()) { // loop until ready
...
}
std::cout
0/5000
1016 บท 18: เกิด
การ store() ดำเนินการย่อยเรียกว่าตำแหน่งหน่วยความจำที่ได้รับผลกระทบ,
ซึ่ง โดยค่าเริ่มต้นมั่นใจได้ทั้งหมดหน่วยความจำก่อนการดำเนินงาน ว่าอะตอม หรือ ไม่ จะเห็น
หัวข้ออื่นก่อนผลของการดำเนินการจัดเก็บ
ตามลำดับ consumer() หัวข้อดำเนินการวนของโหลด() s และประมวลผลข้อมูลแล้ว:
ขณะ (! readyFlagload()) { / / วนรอบจนกว่าจะพร้อม
...
}
std::cout << ข้อมูล << std::endl / / และกระบวนการที่ให้ข้อมูล
การ load() ทำเรียกว่าได้รับการดำเนินงานในตำแหน่งหน่วยความจำที่ได้รับผลกระทบ,
ซึ่ง โดยค่าเริ่มต้นมั่นใจได้ทั้งหมดต่อการดำเนินงานของหน่วยความจำ ว่าอะตอม หรือ ไม่ เป็น
เห็นกระทู้อื่น ๆ หลังจากการดำเนินงานผลิต
ผล เนื่องจากการตั้งค่าของข้อมูลที่เกิดขึ้นก่อน provider() เก็บจริงใน
การ readyFlag และการประมวลผลของข้อมูลเกิดขึ้นหลังจาก consumer() ได้โหลดกับค่า
ของ readyFlag การประมวลผลข้อมูลรับประกันว่า จะเกิดขึ้นหลังจากที่ให้ข้อมูล
รับประกันนี้ไว้เนื่องจากในการดำเนินงานอะตอมทั้งหมด เราใช้การหน่วยความจำเริ่มต้น
ชื่อ memory_order_seq_cst, ซึ่งหมายถึงการจำตามลำดับสอดคล้องกัน กับ lowlevel
atomics ดำเนิน เราจะสามารถผ่อนคลายรับประกันนี้สั่ง (ดู 18.7.4 หน้า 1019,
สำหรับรายละเอียด) .
18.7.2 Atomics และ High-Level อินเทอร์เฟซของพวกเขาในรายละเอียด
ใน , <>std::atomic แม่ชั้นแสดงความสามารถทั่วไปของข้อมูลอะตอมชนิด
สามารถใช้สำหรับชนิดใด ๆ เล็กน้อยได้ สายอาชีพมีการ bool ชนิดรวมเป็นทั้งหมด และ
ตัวชี้:
แม่ < typename T > struct อะตอม; / / หลักคลาสเท็มเพลต
แม่<>struct อะตอม ; / / ชัดเจนเชี่ยวชาญ
แม่<>struct อะตอม ;
...
แม่ < typename T > struct อะตอม ; / / บางส่วนเฉพาะทางสำหรับชี้
18.11 ตารางแสดงรายการการดำเนินงานระดับสูงสำหรับ atomics ถ้าเป็นไปได้ จะแมปโดยตรงไปที่
แนะนำ CPU ที่สอดคล้องกัน Triv คอลัมน์ค่าสถานะการดำเนินการสำหรับ std::atomic
atomics ชนิดอื่น ๆ เล็กน้อย และชนิด int คอลัมน์ค่าสถานะการดำเนินการสำหรับ std::atomic <>,
ถ้า ใช้ชนิดเป็น และชนิดโดยใช้ ptr คอลัมน์ค่าสถานะการดำเนินการสำหรับ std::atomic <> ถ้าเป็น
ชี้ชนิดใช้
หมายเหตุของหมายเหตุเกี่ยวกับตารางนี้:
•ในทั่วไป การดำเนินงานผลผลิตสำเนาแทนที่อ้างอิง
•เริ่มต้นตัวสร้างเตรียมใช้งานตัวแปร/วัตถุอย่างสมบูรณ์ การดำเนินการทางกฎหมายเท่านั้น
หลังจากที่เริ่มต้นก่อสร้างโทร atomic_init() เริ่มต้นวัตถุ (ดูส่วน 18.7.1,
page 1013) .
•ตัวสร้างค่าของชนิดเกี่ยวข้องไม่ใช่อะตอม
•ทุกงานยกเว้นมีตัวสร้างโอเวอร์โหลดสำหรับระเหย และไม่-ระเหย
www.it-ebooks.info
18.7 Atomics 1017
ดำเนิน triv int โดยใช้ ptr ผล
พิมพ์ชนิด
อะตอมเป็น =ค่าใช่ใช่ใช่เริ่มต้นที่ มีค่า (ไม่มีอะตอม
ดำเนิน)
อะตอมเป็น ใช่ใช่ใช่ลิชดิตโต atomic_init(&a,val) (โดย atomic_init() การเป็น
ไม่ initialized)
a.is_lock_free() ใช่ใช่ใช่จริงถ้าภายในไม่ใช้ชนิด
locks
a.store(val) ใช่ใช่ใช่กำหนดค่า (void)
a.load() ใช่ใช่ใช่คืนค่าสำเนาของ a
a.exchange(val) ใช่ใช่ใช่กำหนดค่า และคัดลอกของเก่า
ค่าของ a
a.compare_exchange_strong (exp ดำเนินการใช่ใช่ใช่ CAS (ดู below)
des)
a.compare_exchange_weak (exp ใช่ใช่ใช่อ่อนแอ CAS ดำเนิน
เด)
=ค่าใช่ใช่ใช่กำหนด และส่งคืนสำเนาค่า
atomic() ดำเนินการใช่ใช่ใช่คืนค่าสำเนาของ a
a.fetch_add(val) ไม่ใช่อะตอมใช่ =ค่า (คืนค่าสำเนาของ new
value)
a.fetch_sub(val) ไม่ใช่อะตอมใช่-= วาล (คืนสำเนาใหม่
ค่า)
การ =ค่าใช่ใช่เหมือน t.fetch_add (val)
-=วาลใช่ได้เหมือนกันเป็น t.fetch_sub(val)
a ใช่ใช่เรียก t.fetch_add(1) และกลับ
สำเนา 1 หรือ
-เป็น - ใช่ใช่เรียก t.fetch_sub(1) และคืน
สำเนาเป็น a-1
a.fetch_and(val) a& อะตอมใช่หรือ =ค่า (คืนค่าสำเนาของ new
value)
a.fetch_or(val) a| อะตอมใช่ =ค่า (คืนค่าสำเนาของ new
value)
a.fetch_xor(val) ใช่อะตอมเป็น
=ค่า (คืนสำเนาใหม่
ค่า)
& =ค่าใช่เดียวกันเป็น a.fetch_and (val)
เป็น | =ค่าใช่เดียวกันเป็น a.fetch_or (val)
การ
=ค่าใช่เดียวกันเป็น a.fetch_xor (val)
18.11 ตาราง การดำเนินงานสูง Atomics
www.it-ebooks.info
1018 บท 18: เกิด
ตัวอย่าง สำหรับอะตอม < int >, การดำเนินการกำหนดค่าต่อไปนี้จะถูกประกาศ:
namespace มาตรฐาน {
/ / ความเชี่ยวชาญของ<>std::atomic สำหรับ int:
แม่<>struct อะตอม < int > {
สาธารณะ:
/ / ไม่มีตัวดำเนินการกำหนดค่าปกติ:
=(const atomic&) atomic& ดำเนิน =ลบ;
atomic& ดำเนิน =(const atomic&) ระเหย =ลบ;
/ / แต่ให้กำหนดเป็น int ซึ่งทำให้การส่งผ่านอาร์กิวเมนต์:
int ตัว = (int) ระเหย noexcept;
ตัว int = noexcept (int);
...
};
}
is_lock_free() คุณสามารถตรวจสอบว่า การชนิดอะตอมภายในใช้ล็อคให้อะตอม.
ถ้าไม่ คุณมีฮาร์ดแวร์ภาษาสนับสนุนการดำเนินการที่อะตอม (ซึ่งเป็นข้อกำหนดเบื้องต้นสำหรับการใช้
atomics ในตัวจัดการสัญญาณ) ได้
Compare_exchange_strong() และ compare_exchange_weak() จะเรียกว่า compareand-
สลับ (CAS) การดำเนินงาน Cpu มักจะให้การดำเนินการนี้อะตอมเปรียบเทียบเนื้อหาของการ
ตำแหน่งหน่วยความจำการกำหนดค่า และ เมื่อพวกเดียวกัน ปรับเปลี่ยนเนื้อหาของหน่วยความจำ
ตั้งค่าใหม่ให้ นี้เป็นรับประกันว่า ค่าใหม่จะคำนวณตามค่าวัน
ข้อมูล ผลคือสิ่งที่ต้องการรหัสเทียมต่อไปนี้:
compare_exchange_strong bool (คาดว่า T&, T ต้อง)
{
ถ้า (นี้-> load() ==คาดว่า) {
นี้-> (ต้อง); ร้านค้า
กลับจริง;
}
อื่น {
คาดว่า =นี้->โหลด();
กลับเท็จ;
}
}
ดังนั้น ถ้าค่าที่ได้รับการปรับปรุง โดยเธรดอื่นในขณะเดียวกัน จะส่งกลับเท็จกับ
คาดว่าค่าใหม่ในการ
แบบอ่อนแอ spuriously อาจล้มเหลวเพื่อที่จะส่งกลับเท็จแม้เมื่อคาด
ปัจจุบันได้ แต่แบบอ่อนแอเป็นบางครั้งมีประสิทธิภาพกว่าแข็งแรงรุ่น.
www.it-ebooks.info
18.7 Atomics 1019
18.7.3 อินเทอร์เฟซของเดอะสไตล์ C Atomics
สำหรับข้อเสนอที่อะตอมสำหรับ C มีข้อเสนอที่สอดคล้องกันสำหรับ C ซึ่งควรให้
ความหมายเดียวกันแต่ได้ แน่นอน ใช้คุณลักษณะดังกล่าว C ระบุเป็นแม่แบบ อ้างอิง,
และฟังก์ชันสมาชิก อินเตอร์เฟซอะตอมทั้งหมดมีการเทียบเท่ากับแบบ C ซึ่งยัง
ถูกเสนอเป็นมาตรฐาน C ได้
ตัวอย่าง คุณสามารถประกาศการ อะตอมเป็น atomic_bool และแทนที่จะเก็บ()
load() คุณสามารถใช้ฟังก์ชัน ใช้ตัวชี้ไปวัตถุ:
std::atomic_bool ab / / เท่ากับ: std::atomic ab
std::atomic_init(&ab,false); / / ดูส่วน 18.7.1 เพ 1013
...
std::atomic_store(&ab,true); / / เท่ากับ: ab.store (ทรู)
...
ถ้า (std::atomic_load(&ab)) { / / เท่ากับ: ถ้า (ab.load())
...
}
อย่างไรก็ตาม C เพิ่มอินเทอร์เฟซอื่น ใช้เพื่ออินเทอร์เฟซแบบ C ใน _Atomic และ _Atomic()
ทั่วไปใช้สำหรับรหัสที่จำเป็นต้องใช้ C และคอมไพล์ได้ใน term. เอื้อม C
อย่างไรก็ตาม โดยใช้ชนิดของอะตอม C-ลักษณะเป็นสวยใน C ตารางที่ 18.12 แสดงรายการสำคัญสุด
ชื่อชนิดอะตอม มีมากมีน้อยทั่วไปชนิด เช่น
atomic_int_fast32_t สำหรับอะตอม .
หมายเหตุว่า สำหรับใช้ร่วมกัน (ดูหัวข้อ 5.2.1 ตัวชี้ หน้า 76) การดำเนินการที่อะตอมที่พิเศษมีการ
เหตุผลว่าการประกาศ เช่นอะตอม < shared_ptr > เป็นไปไม่ได้ เนื่องจากใช้ร่วมกัน
ชี้ไม่ trivially copyable การดำเนินการที่อะตอมทำตามแผนของแบบ C
อินเทอร์เฟซ ดูหัวข้อ 5.2.4 หน้า 96 สำหรับรายละเอียด
18.7.4 อินเทอร์เฟซของระดับต่ำ Atomics
อินเทอร์เฟซระดับต่ำของ atomics หมายถึง การใช้การดำเนินการที่อะตอมในแบบที่เราไม่มี
รับประกันความสอดคล้องต่อเนื่องกัน จึง ฮาร์ดแวร์และคอมไพเลอร์อาจ (บางส่วน) สั่งเข้า
บน atomics (ดูส่วน 18.4.3 หน้า 986) .
ระวังอีก: แม้ว่าฉันให้ตัวอย่าง บริเวณนี้มีการระเบิดได้ คุณจำนวนมากของผู้เชี่ยวชาญการ
รู้เมื่อหน่วยความจำ reorderings จะพยายาม และแม้แต่ผู้เชี่ยวชาญมักจะทำผิดพลาดใน this
area.27
An ผู้เชี่ยวชาญโดยใช้คุณลักษณะนี้ควรจะคุ้นเคยกับวัสดุที่กล่าวถึงใน [N2480:MemMod]
และ [BoehmAdve:MemMod] หรือ ทั่วไป วัสดุทั้งหมดที่ [Boehm: C MM] .
พิเศษ 27 Boehm ฮันส์และ Bartosz Milewski สำหรับการสนับสนุนของพวกเขาให้ฉันนี้ และพวกเขา
ช่วยในการให้บริการข้อความด้านขวา ข้อบกพร่องใด ๆ เป็นความผิดของฉัน.
www.it-ebooks.info
1020 บท 18: เกิด
ชื่อชนิดสอดคล้องชนิด
อะตอม atomic_bool
atomic_char อะตอม
atomic_schar อะตอม <เซ็นชื่ออักขระ >
atomic_uchar อะตอม <รับรองอักขระ >
อะตอม atomic_short
atomic_ushort อะตอม <รับรองสั้น >
อะตอม atomic_int
atomic_uint อะตอม <รับรอง int >
อะตอม atomic_long
atomic_ulong อะตอม <รับรองยาว >
atomic_llong อะตอม <ยาวยาว >
atomic_ullong อะตอม <รับรองยาวนาน >
atomic_char16_t อะตอม
atomic_char32_t อะตอม
อะตอม atomic_wchar_t
atomic_intptr_t อะตอม
อะตอม atomic_uintptr_t
atomic_size_t อะตอม
อะตอม atomic_ptrdiff_t
atomic_intmax_t อะตอม
atomic_uintmax_t อะตอม
18.12 ตาราง บางชนิดชื่อของ std::atomic <>
อย่างอันสำหรับอินเทอร์เฟซ Atomics ระดับต่ำ
พิจารณาตัวอย่างที่สองสำหรับใช้ atomics ในส่วน 18.7.1 หน้า 1014 ที่เรา
ประกาศสถานะอะตอมเพื่อควบคุมการเข้าถึงข้อมูลบางอย่าง:
ข้อมูลยาว;
std:: readyFlag อะตอม (เท็จ);
และหัวข้อที่ให้ข้อมูล:
ข้อมูล = 42; / / ให้บาง data
readyFlag.store(true); / / และสัญญาณพร้อม
และหัวข้อการใช้ข้อมูล:
ขณะ (! readyFlag.load()) { / / วนรอบจนกว่าจะพร้อม
...
}
std::cout << ข้อมูล << std::endl / / และกระบวนการที่ให้ข้อมูล
เนื่องจากเราใช้หน่วยความจำลำดับการเริ่มต้น ซึ่งสอดคล้องตามลำดับ นี้ทำงานเป็น
อธิบายไว้ในส่วน 18.7.1 หน้า 1015 ในความเป็นจริง สิ่งเราจริง ๆ โทรถูก:
www.it-ebooks.info
18.7 Atomics 1021
ข้อมูล = 42;
readyFlag.store (ทรู std::memory_order_seq_cst);
และ
ขณะ (! readyFlag.load(std::memory_order_seq_cst)) {
...
}
std::cout << ข้อมูล << std::endl;
ดัง ดำเนินงานมีอาร์กิวเมนต์ตัวเลือกผ่านใบสั่งหน่วยความจำ ซึ่ง โดยค่าเริ่มต้นเป็น
std::memory_order_seq_cst
การ store() ดำเนินการย่อยเรียกว่าตำแหน่งหน่วยความจำที่ได้รับผลกระทบ,
ซึ่ง โดยค่าเริ่มต้นมั่นใจได้ทั้งหมดหน่วยความจำก่อนการดำเนินงาน ว่าอะตอม หรือ ไม่ จะเห็น
หัวข้ออื่นก่อนผลของการดำเนินการจัดเก็บ
ตามลำดับ consumer() หัวข้อดำเนินการวนของโหลด() s และประมวลผลข้อมูลแล้ว:
ขณะ (! readyFlagload()) { / / วนรอบจนกว่าจะพร้อม
...
}
std::cout << ข้อมูล << std::endl / / และกระบวนการที่ให้ข้อมูล
การ load() ทำเรียกว่าได้รับการดำเนินงานในตำแหน่งหน่วยความจำที่ได้รับผลกระทบ,
ซึ่ง โดยค่าเริ่มต้นมั่นใจได้ทั้งหมดต่อการดำเนินงานของหน่วยความจำ ว่าอะตอม หรือ ไม่ เป็น
เห็นกระทู้อื่น ๆ หลังจากการดำเนินงานผลิต
ผล เนื่องจากการตั้งค่าของข้อมูลที่เกิดขึ้นก่อน provider() เก็บจริงใน
การ readyFlag และการประมวลผลของข้อมูลเกิดขึ้นหลังจาก consumer() ได้โหลดกับค่า
ของ readyFlag การประมวลผลข้อมูลรับประกันว่า จะเกิดขึ้นหลังจากที่ให้ข้อมูล
รับประกันนี้ไว้เนื่องจากในการดำเนินงานอะตอมทั้งหมด เราใช้การหน่วยความจำเริ่มต้น
ชื่อ memory_order_seq_cst, ซึ่งหมายถึงการจำตามลำดับสอดคล้องกัน กับ lowlevel
atomics ดำเนิน เราจะสามารถผ่อนคลายรับประกันนี้สั่ง (ดู 18.7.4 หน้า 1019,
สำหรับรายละเอียด) .
18.7.2 Atomics และ High-Level อินเทอร์เฟซของพวกเขาในรายละเอียด
ใน , <>std::atomic แม่ชั้นแสดงความสามารถทั่วไปของข้อมูลอะตอมชนิด
สามารถใช้สำหรับชนิดใด ๆ เล็กน้อยได้ สายอาชีพมีการ bool ชนิดรวมเป็นทั้งหมด และ
ตัวชี้:
แม่ < typename T > struct อะตอม; / / หลักคลาสเท็มเพลต
แม่<>struct อะตอม ; / / ชัดเจนเชี่ยวชาญ
แม่<>struct อะตอม ;
...
แม่ < typename T > struct อะตอม ; / / บางส่วนเฉพาะทางสำหรับชี้
18.11 ตารางแสดงรายการการดำเนินงานระดับสูงสำหรับ atomics ถ้าเป็นไปได้ จะแมปโดยตรงไปที่
แนะนำ CPU ที่สอดคล้องกัน Triv คอลัมน์ค่าสถานะการดำเนินการสำหรับ std::atomic
atomics ชนิดอื่น ๆ เล็กน้อย และชนิด int คอลัมน์ค่าสถานะการดำเนินการสำหรับ std::atomic <>,
ถ้า ใช้ชนิดเป็น และชนิดโดยใช้ ptr คอลัมน์ค่าสถานะการดำเนินการสำหรับ std::atomic <> ถ้าเป็น
ชี้ชนิดใช้
หมายเหตุของหมายเหตุเกี่ยวกับตารางนี้:
•ในทั่วไป การดำเนินงานผลผลิตสำเนาแทนที่อ้างอิง
•เริ่มต้นตัวสร้างเตรียมใช้งานตัวแปร/วัตถุอย่างสมบูรณ์ การดำเนินการทางกฎหมายเท่านั้น
หลังจากที่เริ่มต้นก่อสร้างโทร atomic_init() เริ่มต้นวัตถุ (ดูส่วน 18.7.1,
page 1013) .
•ตัวสร้างค่าของชนิดเกี่ยวข้องไม่ใช่อะตอม
•ทุกงานยกเว้นมีตัวสร้างโอเวอร์โหลดสำหรับระเหย และไม่-ระเหย
www.it-ebooks.info
18.7 Atomics 1017
ดำเนิน triv int โดยใช้ ptr ผล
พิมพ์ชนิด
อะตอมเป็น =ค่าใช่ใช่ใช่เริ่มต้นที่ มีค่า (ไม่มีอะตอม
ดำเนิน)
อะตอมเป็น ใช่ใช่ใช่ลิชดิตโต atomic_init(&a,val) (โดย atomic_init() การเป็น
ไม่ initialized)
a.is_lock_free() ใช่ใช่ใช่จริงถ้าภายในไม่ใช้ชนิด
locks
a.store(val) ใช่ใช่ใช่กำหนดค่า (void)
a.load() ใช่ใช่ใช่คืนค่าสำเนาของ a
a.exchange(val) ใช่ใช่ใช่กำหนดค่า และคัดลอกของเก่า
ค่าของ a
a.compare_exchange_strong (exp ดำเนินการใช่ใช่ใช่ CAS (ดู below)
des)
a.compare_exchange_weak (exp ใช่ใช่ใช่อ่อนแอ CAS ดำเนิน
เด)
=ค่าใช่ใช่ใช่กำหนด และส่งคืนสำเนาค่า
atomic() ดำเนินการใช่ใช่ใช่คืนค่าสำเนาของ a
a.fetch_add(val) ไม่ใช่อะตอมใช่ =ค่า (คืนค่าสำเนาของ new
value)
a.fetch_sub(val) ไม่ใช่อะตอมใช่-= วาล (คืนสำเนาใหม่
ค่า)
การ =ค่าใช่ใช่เหมือน t.fetch_add (val)
-=วาลใช่ได้เหมือนกันเป็น t.fetch_sub(val)
a ใช่ใช่เรียก t.fetch_add(1) และกลับ
สำเนา 1 หรือ
-เป็น - ใช่ใช่เรียก t.fetch_sub(1) และคืน
สำเนาเป็น a-1
a.fetch_and(val) a& อะตอมใช่หรือ =ค่า (คืนค่าสำเนาของ new
value)
a.fetch_or(val) a| อะตอมใช่ =ค่า (คืนค่าสำเนาของ new
value)
a.fetch_xor(val) ใช่อะตอมเป็น
=ค่า (คืนสำเนาใหม่
ค่า)
& =ค่าใช่เดียวกันเป็น a.fetch_and (val)
เป็น | =ค่าใช่เดียวกันเป็น a.fetch_or (val)
การ
=ค่าใช่เดียวกันเป็น a.fetch_xor (val)
18.11 ตาราง การดำเนินงานสูง Atomics
www.it-ebooks.info
1018 บท 18: เกิด
ตัวอย่าง สำหรับอะตอม < int >, การดำเนินการกำหนดค่าต่อไปนี้จะถูกประกาศ:
namespace มาตรฐาน {
/ / ความเชี่ยวชาญของ<>std::atomic สำหรับ int:
แม่<>struct อะตอม < int > {
สาธารณะ:
/ / ไม่มีตัวดำเนินการกำหนดค่าปกติ:
=(const atomic&) atomic& ดำเนิน =ลบ;
atomic& ดำเนิน =(const atomic&) ระเหย =ลบ;
/ / แต่ให้กำหนดเป็น int ซึ่งทำให้การส่งผ่านอาร์กิวเมนต์:
int ตัว = (int) ระเหย noexcept;
ตัว int = noexcept (int);
...
};
}
is_lock_free() คุณสามารถตรวจสอบว่า การชนิดอะตอมภายในใช้ล็อคให้อะตอม.
ถ้าไม่ คุณมีฮาร์ดแวร์ภาษาสนับสนุนการดำเนินการที่อะตอม (ซึ่งเป็นข้อกำหนดเบื้องต้นสำหรับการใช้
atomics ในตัวจัดการสัญญาณ) ได้
Compare_exchange_strong() และ compare_exchange_weak() จะเรียกว่า compareand-
สลับ (CAS) การดำเนินงาน Cpu มักจะให้การดำเนินการนี้อะตอมเปรียบเทียบเนื้อหาของการ
ตำแหน่งหน่วยความจำการกำหนดค่า และ เมื่อพวกเดียวกัน ปรับเปลี่ยนเนื้อหาของหน่วยความจำ
ตั้งค่าใหม่ให้ นี้เป็นรับประกันว่า ค่าใหม่จะคำนวณตามค่าวัน
ข้อมูล ผลคือสิ่งที่ต้องการรหัสเทียมต่อไปนี้:
compare_exchange_strong bool (คาดว่า T&, T ต้อง)
{
ถ้า (นี้-> load() ==คาดว่า) {
นี้-> (ต้อง); ร้านค้า
กลับจริง;
}
อื่น {
คาดว่า =นี้->โหลด();
กลับเท็จ;
}
}
ดังนั้น ถ้าค่าที่ได้รับการปรับปรุง โดยเธรดอื่นในขณะเดียวกัน จะส่งกลับเท็จกับ
คาดว่าค่าใหม่ในการ
แบบอ่อนแอ spuriously อาจล้มเหลวเพื่อที่จะส่งกลับเท็จแม้เมื่อคาด
ปัจจุบันได้ แต่แบบอ่อนแอเป็นบางครั้งมีประสิทธิภาพกว่าแข็งแรงรุ่น.
www.it-ebooks.info
18.7 Atomics 1019
18.7.3 อินเทอร์เฟซของเดอะสไตล์ C Atomics
สำหรับข้อเสนอที่อะตอมสำหรับ C มีข้อเสนอที่สอดคล้องกันสำหรับ C ซึ่งควรให้
ความหมายเดียวกันแต่ได้ แน่นอน ใช้คุณลักษณะดังกล่าว C ระบุเป็นแม่แบบ อ้างอิง,
และฟังก์ชันสมาชิก อินเตอร์เฟซอะตอมทั้งหมดมีการเทียบเท่ากับแบบ C ซึ่งยัง
ถูกเสนอเป็นมาตรฐาน C ได้
ตัวอย่าง คุณสามารถประกาศการ อะตอมเป็น atomic_bool และแทนที่จะเก็บ()
load() คุณสามารถใช้ฟังก์ชัน ใช้ตัวชี้ไปวัตถุ:
std::atomic_bool ab / / เท่ากับ: std::atomic ab
std::atomic_init(&ab,false); / / ดูส่วน 18.7.1 เพ 1013
...
std::atomic_store(&ab,true); / / เท่ากับ: ab.store (ทรู)
...
ถ้า (std::atomic_load(&ab)) { / / เท่ากับ: ถ้า (ab.load())
...
}
อย่างไรก็ตาม C เพิ่มอินเทอร์เฟซอื่น ใช้เพื่ออินเทอร์เฟซแบบ C ใน _Atomic และ _Atomic()
ทั่วไปใช้สำหรับรหัสที่จำเป็นต้องใช้ C และคอมไพล์ได้ใน term. เอื้อม C
อย่างไรก็ตาม โดยใช้ชนิดของอะตอม C-ลักษณะเป็นสวยใน C ตารางที่ 18.12 แสดงรายการสำคัญสุด
ชื่อชนิดอะตอม มีมากมีน้อยทั่วไปชนิด เช่น
atomic_int_fast32_t สำหรับอะตอม .
หมายเหตุว่า สำหรับใช้ร่วมกัน (ดูหัวข้อ 5.2.1 ตัวชี้ หน้า 76) การดำเนินการที่อะตอมที่พิเศษมีการ
เหตุผลว่าการประกาศ เช่นอะตอม < shared_ptr > เป็นไปไม่ได้ เนื่องจากใช้ร่วมกัน
ชี้ไม่ trivially copyable การดำเนินการที่อะตอมทำตามแผนของแบบ C
อินเทอร์เฟซ ดูหัวข้อ 5.2.4 หน้า 96 สำหรับรายละเอียด
18.7.4 อินเทอร์เฟซของระดับต่ำ Atomics
อินเทอร์เฟซระดับต่ำของ atomics หมายถึง การใช้การดำเนินการที่อะตอมในแบบที่เราไม่มี
รับประกันความสอดคล้องต่อเนื่องกัน จึง ฮาร์ดแวร์และคอมไพเลอร์อาจ (บางส่วน) สั่งเข้า
บน atomics (ดูส่วน 18.4.3 หน้า 986) .
ระวังอีก: แม้ว่าฉันให้ตัวอย่าง บริเวณนี้มีการระเบิดได้ คุณจำนวนมากของผู้เชี่ยวชาญการ
รู้เมื่อหน่วยความจำ reorderings จะพยายาม และแม้แต่ผู้เชี่ยวชาญมักจะทำผิดพลาดใน this
area.27
An ผู้เชี่ยวชาญโดยใช้คุณลักษณะนี้ควรจะคุ้นเคยกับวัสดุที่กล่าวถึงใน [N2480:MemMod]
และ [BoehmAdve:MemMod] หรือ ทั่วไป วัสดุทั้งหมดที่ [Boehm: C MM] .
พิเศษ 27 Boehm ฮันส์และ Bartosz Milewski สำหรับการสนับสนุนของพวกเขาให้ฉันนี้ และพวกเขา
ช่วยในการให้บริการข้อความด้านขวา ข้อบกพร่องใด ๆ เป็นความผิดของฉัน.
www.it-ebooks.info
1020 บท 18: เกิด
ชื่อชนิดสอดคล้องชนิด
อะตอม atomic_bool
atomic_char อะตอม
atomic_schar อะตอม <เซ็นชื่ออักขระ >
atomic_uchar อะตอม <รับรองอักขระ >
อะตอม atomic_short
atomic_ushort อะตอม <รับรองสั้น >
อะตอม atomic_int
atomic_uint อะตอม <รับรอง int >
อะตอม atomic_long
atomic_ulong อะตอม <รับรองยาว >
atomic_llong อะตอม <ยาวยาว >
atomic_ullong อะตอม <รับรองยาวนาน >
atomic_char16_t อะตอม
atomic_char32_t อะตอม
อะตอม atomic_wchar_t
atomic_intptr_t อะตอม
อะตอม atomic_uintptr_t
atomic_size_t อะตอม
อะตอม atomic_ptrdiff_t
atomic_intmax_t อะตอม
atomic_uintmax_t อะตอม
18.12 ตาราง บางชนิดชื่อของ std::atomic <>
อย่างอันสำหรับอินเทอร์เฟซ Atomics ระดับต่ำ
พิจารณาตัวอย่างที่สองสำหรับใช้ atomics ในส่วน 18.7.1 หน้า 1014 ที่เรา
ประกาศสถานะอะตอมเพื่อควบคุมการเข้าถึงข้อมูลบางอย่าง:
ข้อมูลยาว;
std:: readyFlag อะตอม (เท็จ);
และหัวข้อที่ให้ข้อมูล:
ข้อมูล = 42; / / ให้บาง data
readyFlag.store(true); / / และสัญญาณพร้อม
และหัวข้อการใช้ข้อมูล:
ขณะ (! readyFlag.load()) { / / วนรอบจนกว่าจะพร้อม
...
}
std::cout << ข้อมูล << std::endl / / และกระบวนการที่ให้ข้อมูล
เนื่องจากเราใช้หน่วยความจำลำดับการเริ่มต้น ซึ่งสอดคล้องตามลำดับ นี้ทำงานเป็น
อธิบายไว้ในส่วน 18.7.1 หน้า 1015 ในความเป็นจริง สิ่งเราจริง ๆ โทรถูก:
www.it-ebooks.info
18.7 Atomics 1021
ข้อมูล = 42;
readyFlag.store (ทรู std::memory_order_seq_cst);
และ
ขณะ (! readyFlag.load(std::memory_order_seq_cst)) {
...
}
std::cout << ข้อมูล << std::endl;
ดัง ดำเนินงานมีอาร์กิวเมนต์ตัวเลือกผ่านใบสั่งหน่วยความจำ ซึ่ง โดยค่าเริ่มต้นเป็น
std::memory_order_seq_cst
การแปล กรุณารอสักครู่..
1016 บทที่ 18: Concurrency
เก็บ () การดำเนินงานที่มีประสิทธิภาพการดำเนินงานที่เป็นอิสระที่เรียกว่าหน่วยความจำกับสถานที่ได้รับผลกระทบ
ซึ่งโดยค่าเริ่มต้นเพื่อให้แน่ใจว่าการดำเนินงานของหน่วยความจำก่อนที่ทุกคนไม่ว่าอะตอมหรือไม่กลายเป็นมองเห็น
หัวข้ออื่น ๆ ก่อนที่จะมีผลการดำเนินงานของร้านค้า .
ดังนั้นผู้บริโภคด้าย () ดำเนินการห่วงของโหลด () และข้อมูลกระบวนการแล้ว:
ในขณะที่ {/ / ห่วงจนกว่าจะพร้อม (readyFlag.load ())
...
}
std :: ศาล << ข้อมูล << มาตรฐาน: : endl / / และขั้นตอนการให้ข้อมูล
โหลด () การดำเนินงานที่มีประสิทธิภาพการดำเนินงานที่ได้มาเรียกว่าที่ตั้งหน่วยความจำได้รับผลกระทบ
ซึ่งโดยค่าเริ่มต้นเพื่อให้แน่ใจว่าการดำเนินงานหน่วยความจำต่อไปนี้ไม่ว่าจะเป็นอะตอมหรือไม่กลายเป็น
มองเห็นหัวข้ออื่น ๆ หลังจากโหลด การดำเนินการ
ที่เป็นผลเนื่องจากการตั้งค่าของข้อมูลที่เกิดขึ้นก่อนที่ผู้ให้บริการ () ร้านค้าจริงใน
readyFlag และการประมวลผลของข้อมูลที่เกิดขึ้นหลังจากผู้บริโภค () มีการโหลดจริงเป็นค่า
ของ readyFlag, การประมวลผลของข้อมูลที่มีการรับประกันว่าจะเกิดขึ้น หลังจากที่ข้อมูลถูกจัดให้
การรับประกันนี้จะให้เพราะในการดำเนินงานของอะตอมทั้งหมดที่เราจะใช้หน่วยความจำเพื่อเริ่มต้น
การตั้งชื่อ memory_order_seq_cst ซึ่งย่อมาจากลำดับการสั่งซื้อหน่วยความจำที่สอดคล้องกัน ด้วย lowlevel
การดำเนินงานอะตอม, เราสามารถที่จะผ่อนคลายการรับประกันคำสั่งนี้ (ดูมาตรา 18.7.4, หน้า 1019,
สำหรับรายละเอียด)
18.7.2 อะตอมและระดับสูงรูปแบบของพวกเขาในรายละเอียด
ใน, แม่แบบคลาส std :: อะตอม <> ให้ความสามารถทั่วไปของชนิดข้อมูลอะตอม
มันสามารถใช้สำหรับประเภทใด ๆ จิ๊บจ๊อย เฉพาะมีไว้สำหรับบูลชนิดหนึ่งทั้งหมดและ
ตัวชี้:
แม่แบบโครงสร้างอะตอม / / หลักแม่แบบคลาส
แม่ <> struct อะตอม/ / เฉพาะที่ชัดเจน
แม่ <> struct อะตอม;
...
แม่ โครงสร้างอะตอม; ความเชี่ยวชาญ / / บางส่วนสำหรับตัวชี้
ตารางที่ 18.11 รายการการดำเนินงานในระดับสูงให้อะตอม ถ้าเป็นไปได้ที่พวกเขาแผนที่โดยตรงกับ
คำแนะนำที่สอดคล้องกับซีพียู การดำเนินงานธง triv คอลัมน์ให้ std :: อะตอม
และอะตอมประเภทจิ๊บจ๊อยอื่น ๆ การดำเนินการ int ชนิดคอลัมน์ธงให้ std :: อะตอม <>
ถ้าชนิดหนึ่งถูกนำมาใช้และการดำเนินงานประเภท PTR คอลัมน์ธงให้ std :: อะตอม <> ถ้า
ประเภทตัวชี้จะใช้
หมายเหตุคู่ของข้อสังเกตเกี่ยวกับตารางนี้:
•โดยทั่วไปแล้วการดำเนินงานให้สำเนามากกว่าการอ้างอิง
•สร้างการเริ่มต้นไม่ได้เริ่มต้นตัวแปร / object อย่างสมบูรณ์ การดำเนินการทางกฎหมายเพียง แต่
หลังจากการก่อสร้างเริ่มต้นจะเรียก atomic_init () เพื่อเริ่มต้นวัตถุ (ดูมาตรา 18.7.1,
หน้า 1013)
•การสร้างมูลค่าของประเภทที่เกี่ยวข้องไม่ได้เป็นอะตอม
•ฟังก์ชั่นทั้งหมดยกเว้นการก่อสร้างมีมากเกินไปในการระเหย และไม่ระเหย
www.it-ebooks.info
18.7 อะตอม 1,017
กิจการ triv ผล int PTR
ประเภทประเภท
อะตอม val = ใช่ใช่ใช่เริ่มต้นด้วยวาล (ไม่อะตอม
การทำงาน)
อะตอม; atomic_init (และวาล) ใช่ใช่ ใช่เช่นเดียวกัน (โดยไม่ต้อง atomic_init () จะ
ไม่ได้เริ่มต้น)
a.is_lock_free () ใช่ใช่ใช่จริงถ้าประเภทภายในไม่ได้ใช้
ล็อค
a.store (วาล) ใช่ใช่ใช่กําหนดวาล (ผลตอบแทนที่เป็นโมฆะ)
a.load () ใช่ ใช่ใช่คัดลอกผลตอบแทนของมูลค่า
a.exchange (วาล) ใช่ใช่ใช่กําหนดวาลและผลตอบแทนที่คัดลอกของเดิม
ค่าของ
a.compare_exchange_strong (exp, ใช่ใช่ใช่การดำเนิน CAS (ดูด้านล่าง)
des)
a.compare_exchange_weak (exp , ใช่ใช่ใช่การดำเนิน CAS อ่อนแอ
des)
val = ใช่ใช่ใช่กําหนดและผลตอบแทนที่คัดลอกของวาล
a.operator อะตอม () ใช่ใช่ใช่คัดลอกผลตอบแทนของมูลค่า
a.fetch_add (วาล) ใช่ใช่เสื้อปรมาณู + val = ( ผลตอบแทนที่ได้คัดลอกของใหม่
ค่า)
a.fetch_sub (วาล) ใช่ใช่ปรมาณูเสื้อ val = (ผลตอบแทนที่คัดลอกใหม่
ค่า)
+ val = ใช่เหมือนกับ t.fetch_add (วาล)
- = วาลใช่ใช่เช่นเดียวกับเสื้อ fetch_sub (วาล)
+ + +, + + + ใช่ใช่โทร t.fetch_add (1) และผลตอบแทน
ของการคัดลอกหรือ 1
-, - ใช่ใช่โทร t.fetch_sub (1) และผลตอบแทน
ของการคัดลอกหรือ -1
a.fetch_and (วาล) ใช่ปรมาณูและ val = (ผลตอบแทนที่คัดลอกใหม่
ค่า)
a.fetch_or (วาล) ใช่ปรมาณู | val = (ผลตอบแทนที่คัดลอกใหม่
ค่า)
a.fetch_xor (วาล) ใช่ปรมาณู ^ = วาล (ผลตอบแทนที่คัดลอกใหม่
ค่า)
และ val = ใช่เหมือนกับ a.fetch_and (วาล)
| val = ใช่เหมือนกับ a.fetch_or (วาล)
^ val = ใช่เหมือนกับ a.fetch_xor (วาล)
ตารางที่ 18.11 ระดับสูงการดำเนินงานของอะตอม
www.it-ebooks.info
1018 บทที่ 18: Concurrency
ตัวอย่างเช่นสำหรับอะตอม, การดำเนินงานที่ได้รับมอบหมายต่อไปนี้มีการประกาศ:
namespace std {
/ / ความเชี่ยวชาญของ std :: อะตอม <> เพื่อ int:
แม่ <> struct อะตอม{
สาธารณะ:
ผู้ประกอบการ / / มอบหมายสามัญไม่ให้:
อะตอมและดำเนินการ = (const อะตอมและ) = ลบ;
อะตอมและดำเนินการ = (const อะตอมและ) ระเหย = ลบ;
/ / แต่ที่ได้รับมอบหมายของ int มีให้ที่ทำให้อาร์กิวเมนต์ผ่าน:
int ดำเนินการ = (int) ระเหย noexcept;
int ดำเนินการ = (int) noexcept;
...
};
}
ด้วย is_lock_free () คุณสามารถตรวจสอบว่าประเภทของอะตอมภายในใช้ล็อคจะเป็นอะตอม
ถ้าไม่คุณมีการสนับสนุนพื้นเมืองสำหรับฮาร์ดแวร์ การดำเนินงานของอะตอม (ซึ่งเป็นสิ่งที่จำเป็นสำหรับการใช้
อะตอมในตัวจัดการสัญญาณ)
ทั้งสอง compare_exchange_strong () และ compare_exchange_weak () จะถูกเรียกว่า compareand-
swap (CAS) การดำเนินงาน ซีพียูมักจะให้การดำเนินงานของอะตอมนี้เพื่อเปรียบเทียบเนื้อหาของ
ตำแหน่งหน่วยความจำให้เป็นค่าที่กำหนดและเฉพาะในกรณีที่พวกเขามีเหมือนกันปรับเปลี่ยนเนื้อหาของหน่วยความจำที่
ตำแหน่งที่จะค่าใหม่ที่กำหนด นี้รับประกันว่าค่าใหม่จะถูกคำนวณตาม up-to-วันที่
ข้อมูล ผลที่ได้คือสิ่งที่ต้องการ pseudocode ต่อไปนี้
บูล compare_exchange_strong (T & คาด T ต้องการ)
{
ถ้า (โหลด this-> () == คาดว่า) {
this-> ร้านค้า (ที่ต้องการ);
กลับจริง;
}
อื่น {
คาด =-นี้ > โหลด ();
กลับเท็จ;
}
}
ดังนั้นหากค่าที่ได้รับการปรับปรุงโดยหัวข้ออื่นในขณะเดียวกันก็กลับเท็จกับ
ค่าใหม่ในที่คาดว่าจะ
รูปแบบอ่อนแอ spuriously อาจล้มเหลวเพื่อที่จะกลับเท็จแม้ที่คาดว่าจะ ค่า
ปัจจุบัน แต่รูปแบบที่อ่อนแอเป็นบางครั้งมีประสิทธิภาพมากขึ้นกว่ารุ่นที่แข็งแกร่ง
www.it-ebooks.info
18.7 อะตอม 1019
18.7.3 C-อินเตอร์เฟซแบบของอะตอม
สำหรับอะตอมข้อเสนอสำหรับ C + +, มีข้อเสนอที่สอดคล้องกันสำหรับ C ซึ่งควร ให้
ความหมายเหมือนกัน แต่อาจจะแน่นอนไม่ใช้ C + คุณสมบัติเฉพาะเช่น + เป็นแม่แบบการอ้างอิง
และการทำงานของสมาชิก ดังนั้นอินเตอร์เฟซของอะตอมทั้งหมดมีเทียบเท่า C แบบซึ่งยัง
ถูกเสนอเป็นส่วนขยายไปมาตรฐาน C
ตัวอย่างเช่นคุณยังสามารถประกาศอะตอมเป็น atomic_bool และแทนที่จะเก็บ ()
และโหลด () คุณสามารถใช้ฟังก์ชั่นระดับโลกซึ่งใช้ตัวชี้ไปยังวัตถุ:
std :: atomic_bool ข / / เทียบเท่ากับ: std :: อะตอมข
std :: atomic_init (และข, เท็จ) / / ดูส่วน 18.7.1, หน้า 1013
...
std :: atomic_store (และขจริง) / / เทียบเท่ากับ: ab.store (จริง)
...
ถ้า ( std :: atomic_load (และข)) {/ / เทียบเท่ากับ: ถ้า (ab.load ())
...
}
แต่ C เข้ามาติดต่ออื่นโดยใช้ _Atomic และ _Atomic () ดังนั้นอินเตอร์เฟซ C สไตล์
ทั่วไปเป็นประโยชน์ สำหรับรหัสที่จะต้องทั้ง C และ C + + compilable ในระยะใกล้
อย่างไรก็ตามการใช้ชนิดอะตอม C สไตล์เป็นเรื่องธรรมดาสวยใน C + + ตารางที่ 18.12 รายการที่สำคัญที่สุดที่
ชื่อประเภทอะตอม มีให้มากขึ้นสำหรับชนิดที่พบน้อยลงเช่น
atomic_int_fast32_t กับอะตอม.
โปรดทราบว่าสำหรับตัวชี้ที่ใช้ร่วมกัน (ดูมาตรา 5.2.1, หน้า 76) การดำเนินงานของอะตอมพิเศษที่มีให้
เหตุผลก็คือการประกาศเช่นอะตอม> เป็นไปไม่ได้เพราะที่ใช้ร่วมกัน
ไม่ได้เป็นตัวชี้ copyable นิด การดำเนินงานของอะตอมไปตามข้อตกลงการตั้งชื่อของซีสไตล์
อินเตอร์เฟซ ดูมาตรา 5.2.4, หน้า 96 สำหรับรายละเอียด
18.7.4 ต่ำระดับรูปแบบของอะตอม
อินเตอร์เฟซระดับต่ำของอะตอมหมายถึงการใช้การดำเนินงานของอะตอมในทางที่เราไม่มี
ความสอดคล้องต่อเนื่องรับประกัน ดังนั้นคอมไพเลอร์และฮาร์ดแวร์อาจ (บางส่วน) เรียงลำดับการเข้าถึง
ในอะตอม (ดูมาตรา 18.4.3, หน้า 986)
ระวังอีกครั้งแม้ว่าผมจะยกตัวอย่างพื้นที่นี้เป็นเขตที่วางทุ่นระเบิด คุณต้องการมากของความเชี่ยวชาญที่จะ
รู้ว่าเมื่อ reorderings หน่วยความจำที่คุ้มค่าความพยายามและผู้เชี่ยวชาญแม้มักจะทำผิดพลาดในเรื่องนี้
area.27
ผู้เชี่ยวชาญใช้คุณสมบัตินี้ควรจะคุ้นเคยกับวัสดุที่กล่าวถึงใน [N2480: MemMod]
และ [BoehmAdve: MemMod ] หรือโดยทั่วไปวัสดุทั้งหมดที่ระบุไว้ที่ [Boehm: C + + MM]
27 ขอขอบคุณเป็นพิเศษกับฮันส์ Boehm และ Bartosz Milewski สำหรับการสนับสนุนของพวกเขาในการให้ฉันเข้าใจในเรื่องนี้ของพวกเขาและ
ความช่วยเหลือในการให้บริการการใช้ถ้อยคำที่เหมาะสม ข้อบกพร่องใด ๆ เป็นความผิดของฉัน
www.it-ebooks.info
1020 บทที่ 18: Concurrency
ประเภทชื่อประเภทที่สอดคล้องกัน
atomic_bool อะตอม
atomic_char อะตอม
atomic_schar อะตอม
atomic_uchar อะตอม
atomic_short อะตอม
atomic_ushort อะตอม
atomic_int อะตอม
atomic_uint อะตอม
atomic_long อะตอม
atomic_ulong อะตอม
atomic_llong อะตอม
atomic_ullong อะตอม
atomic_char16_t อะตอม
atomic_char32_t อะตอม
atomic_wchar_t อะตอม
atomic_intptr_t อะตอม
atomic_uintptr_t อะตอม
atomic_size_t อะตอม
atomic_ptrdiff_t อะตอม
atomic_intmax_t อะตอม
atomic_uintmax_t อะตอม
ตารางที่ 18.12 บางประเภทของชื่อ std :: อะตอม <>
ตัวอย่างต่ำระดับรูปแบบของอะตอม
พิจารณาตัวอย่างที่สองสำหรับการใช้อะตอมแนะนำในมาตรา 18.7.1, หน้า 1014 ที่เรา
ประกาศธงอะตอมการควบคุมการเข้าถึงข้อมูลบางอย่าง :
ข้อมูลยาว
std :: อะตอมreadyFlag (เท็จ);
และด้ายให้ข้อมูล:
ข้อมูล = 42 / / ให้บางข้อมูล
readyFlag.store (จริง) / / และความพร้อมสัญญาณ
และด้ายบริโภคข้อมูล:
ในขณะที่ {(readyFlag.load ()) / / ห่วงจนพร้อมที่
...
}
std :: ศาล << ข้อมูล << std :: endl / / และขั้นตอนการให้ข้อมูล
เพราะเราใช้เพื่อเริ่มต้นหน่วยความจำซึ่งรับประกันความมั่นคงเรียงตามลำดับงานนี้เป็น
ที่อธิบายไว้ในมาตรา 18.7 1 หน้า 1015 ในความเป็นจริงสิ่งที่เราเรียกจริงๆ:
www.it-ebooks.info
18.7 อะตอม 1021
ข้อมูล = 42;
readyFlag.store (จริง std :: memory_order_seq_cst);
และ
ในขณะที่ {(readyFlag.load (std :: memory_order_seq_cst))
...
}
std :: ศาล << ข้อมูล << std :: endl;
ดังนั้นการดำเนินงานของแต่ละคนมีอาร์กิวเมนต์ตัวเลือกที่จะส่งคำสั่งซื้อหน่วยความจำซึ่งโดยปกติเป็น
std :: memory_order_seq_cst
เก็บ () การดำเนินงานที่มีประสิทธิภาพการดำเนินงานที่เป็นอิสระที่เรียกว่าหน่วยความจำกับสถานที่ได้รับผลกระทบ
ซึ่งโดยค่าเริ่มต้นเพื่อให้แน่ใจว่าการดำเนินงานของหน่วยความจำก่อนที่ทุกคนไม่ว่าอะตอมหรือไม่กลายเป็นมองเห็น
หัวข้ออื่น ๆ ก่อนที่จะมีผลการดำเนินงานของร้านค้า .
ดังนั้นผู้บริโภคด้าย () ดำเนินการห่วงของโหลด () และข้อมูลกระบวนการแล้ว:
ในขณะที่ {/ / ห่วงจนกว่าจะพร้อม (readyFlag.load ())
...
}
std :: ศาล << ข้อมูล << มาตรฐาน: : endl / / และขั้นตอนการให้ข้อมูล
โหลด () การดำเนินงานที่มีประสิทธิภาพการดำเนินงานที่ได้มาเรียกว่าที่ตั้งหน่วยความจำได้รับผลกระทบ
ซึ่งโดยค่าเริ่มต้นเพื่อให้แน่ใจว่าการดำเนินงานหน่วยความจำต่อไปนี้ไม่ว่าจะเป็นอะตอมหรือไม่กลายเป็น
มองเห็นหัวข้ออื่น ๆ หลังจากโหลด การดำเนินการ
ที่เป็นผลเนื่องจากการตั้งค่าของข้อมูลที่เกิดขึ้นก่อนที่ผู้ให้บริการ () ร้านค้าจริงใน
readyFlag และการประมวลผลของข้อมูลที่เกิดขึ้นหลังจากผู้บริโภค () มีการโหลดจริงเป็นค่า
ของ readyFlag, การประมวลผลของข้อมูลที่มีการรับประกันว่าจะเกิดขึ้น หลังจากที่ข้อมูลถูกจัดให้
การรับประกันนี้จะให้เพราะในการดำเนินงานของอะตอมทั้งหมดที่เราจะใช้หน่วยความจำเพื่อเริ่มต้น
การตั้งชื่อ memory_order_seq_cst ซึ่งย่อมาจากลำดับการสั่งซื้อหน่วยความจำที่สอดคล้องกัน ด้วย lowlevel
การดำเนินงานอะตอม, เราสามารถที่จะผ่อนคลายการรับประกันคำสั่งนี้ (ดูมาตรา 18.7.4, หน้า 1019,
สำหรับรายละเอียด)
18.7.2 อะตอมและระดับสูงรูปแบบของพวกเขาในรายละเอียด
ใน, แม่แบบคลาส std :: อะตอม <> ให้ความสามารถทั่วไปของชนิดข้อมูลอะตอม
มันสามารถใช้สำหรับประเภทใด ๆ จิ๊บจ๊อย เฉพาะมีไว้สำหรับบูลชนิดหนึ่งทั้งหมดและ
ตัวชี้:
แม่แบบโครงสร้างอะตอม / / หลักแม่แบบคลาส
แม่ <> struct อะตอม/ / เฉพาะที่ชัดเจน
แม่ <> struct อะตอม;
...
แม่ โครงสร้างอะตอม; ความเชี่ยวชาญ / / บางส่วนสำหรับตัวชี้
ตารางที่ 18.11 รายการการดำเนินงานในระดับสูงให้อะตอม ถ้าเป็นไปได้ที่พวกเขาแผนที่โดยตรงกับ
คำแนะนำที่สอดคล้องกับซีพียู การดำเนินงานธง triv คอลัมน์ให้ std :: อะตอม
และอะตอมประเภทจิ๊บจ๊อยอื่น ๆ การดำเนินการ int ชนิดคอลัมน์ธงให้ std :: อะตอม <>
ถ้าชนิดหนึ่งถูกนำมาใช้และการดำเนินงานประเภท PTR คอลัมน์ธงให้ std :: อะตอม <> ถ้า
ประเภทตัวชี้จะใช้
หมายเหตุคู่ของข้อสังเกตเกี่ยวกับตารางนี้:
•โดยทั่วไปแล้วการดำเนินงานให้สำเนามากกว่าการอ้างอิง
•สร้างการเริ่มต้นไม่ได้เริ่มต้นตัวแปร / object อย่างสมบูรณ์ การดำเนินการทางกฎหมายเพียง แต่
หลังจากการก่อสร้างเริ่มต้นจะเรียก atomic_init () เพื่อเริ่มต้นวัตถุ (ดูมาตรา 18.7.1,
หน้า 1013)
•การสร้างมูลค่าของประเภทที่เกี่ยวข้องไม่ได้เป็นอะตอม
•ฟังก์ชั่นทั้งหมดยกเว้นการก่อสร้างมีมากเกินไปในการระเหย และไม่ระเหย
www.it-ebooks.info
18.7 อะตอม 1,017
กิจการ triv ผล int PTR
ประเภทประเภท
อะตอม val = ใช่ใช่ใช่เริ่มต้นด้วยวาล (ไม่อะตอม
การทำงาน)
อะตอม; atomic_init (และวาล) ใช่ใช่ ใช่เช่นเดียวกัน (โดยไม่ต้อง atomic_init () จะ
ไม่ได้เริ่มต้น)
a.is_lock_free () ใช่ใช่ใช่จริงถ้าประเภทภายในไม่ได้ใช้
ล็อค
a.store (วาล) ใช่ใช่ใช่กําหนดวาล (ผลตอบแทนที่เป็นโมฆะ)
a.load () ใช่ ใช่ใช่คัดลอกผลตอบแทนของมูลค่า
a.exchange (วาล) ใช่ใช่ใช่กําหนดวาลและผลตอบแทนที่คัดลอกของเดิม
ค่าของ
a.compare_exchange_strong (exp, ใช่ใช่ใช่การดำเนิน CAS (ดูด้านล่าง)
des)
a.compare_exchange_weak (exp , ใช่ใช่ใช่การดำเนิน CAS อ่อนแอ
des)
val = ใช่ใช่ใช่กําหนดและผลตอบแทนที่คัดลอกของวาล
a.operator อะตอม () ใช่ใช่ใช่คัดลอกผลตอบแทนของมูลค่า
a.fetch_add (วาล) ใช่ใช่เสื้อปรมาณู + val = ( ผลตอบแทนที่ได้คัดลอกของใหม่
ค่า)
a.fetch_sub (วาล) ใช่ใช่ปรมาณูเสื้อ val = (ผลตอบแทนที่คัดลอกใหม่
ค่า)
+ val = ใช่เหมือนกับ t.fetch_add (วาล)
- = วาลใช่ใช่เช่นเดียวกับเสื้อ fetch_sub (วาล)
+ + +, + + + ใช่ใช่โทร t.fetch_add (1) และผลตอบแทน
ของการคัดลอกหรือ 1
-, - ใช่ใช่โทร t.fetch_sub (1) และผลตอบแทน
ของการคัดลอกหรือ -1
a.fetch_and (วาล) ใช่ปรมาณูและ val = (ผลตอบแทนที่คัดลอกใหม่
ค่า)
a.fetch_or (วาล) ใช่ปรมาณู | val = (ผลตอบแทนที่คัดลอกใหม่
ค่า)
a.fetch_xor (วาล) ใช่ปรมาณู ^ = วาล (ผลตอบแทนที่คัดลอกใหม่
ค่า)
และ val = ใช่เหมือนกับ a.fetch_and (วาล)
| val = ใช่เหมือนกับ a.fetch_or (วาล)
^ val = ใช่เหมือนกับ a.fetch_xor (วาล)
ตารางที่ 18.11 ระดับสูงการดำเนินงานของอะตอม
www.it-ebooks.info
1018 บทที่ 18: Concurrency
ตัวอย่างเช่นสำหรับอะตอม, การดำเนินงานที่ได้รับมอบหมายต่อไปนี้มีการประกาศ:
namespace std {
/ / ความเชี่ยวชาญของ std :: อะตอม <> เพื่อ int:
แม่ <> struct อะตอม{
สาธารณะ:
ผู้ประกอบการ / / มอบหมายสามัญไม่ให้:
อะตอมและดำเนินการ = (const อะตอมและ) = ลบ;
อะตอมและดำเนินการ = (const อะตอมและ) ระเหย = ลบ;
/ / แต่ที่ได้รับมอบหมายของ int มีให้ที่ทำให้อาร์กิวเมนต์ผ่าน:
int ดำเนินการ = (int) ระเหย noexcept;
int ดำเนินการ = (int) noexcept;
...
};
}
ด้วย is_lock_free () คุณสามารถตรวจสอบว่าประเภทของอะตอมภายในใช้ล็อคจะเป็นอะตอม
ถ้าไม่คุณมีการสนับสนุนพื้นเมืองสำหรับฮาร์ดแวร์ การดำเนินงานของอะตอม (ซึ่งเป็นสิ่งที่จำเป็นสำหรับการใช้
อะตอมในตัวจัดการสัญญาณ)
ทั้งสอง compare_exchange_strong () และ compare_exchange_weak () จะถูกเรียกว่า compareand-
swap (CAS) การดำเนินงาน ซีพียูมักจะให้การดำเนินงานของอะตอมนี้เพื่อเปรียบเทียบเนื้อหาของ
ตำแหน่งหน่วยความจำให้เป็นค่าที่กำหนดและเฉพาะในกรณีที่พวกเขามีเหมือนกันปรับเปลี่ยนเนื้อหาของหน่วยความจำที่
ตำแหน่งที่จะค่าใหม่ที่กำหนด นี้รับประกันว่าค่าใหม่จะถูกคำนวณตาม up-to-วันที่
ข้อมูล ผลที่ได้คือสิ่งที่ต้องการ pseudocode ต่อไปนี้
บูล compare_exchange_strong (T & คาด T ต้องการ)
{
ถ้า (โหลด this-> () == คาดว่า) {
this-> ร้านค้า (ที่ต้องการ);
กลับจริง;
}
อื่น {
คาด =-นี้ > โหลด ();
กลับเท็จ;
}
}
ดังนั้นหากค่าที่ได้รับการปรับปรุงโดยหัวข้ออื่นในขณะเดียวกันก็กลับเท็จกับ
ค่าใหม่ในที่คาดว่าจะ
รูปแบบอ่อนแอ spuriously อาจล้มเหลวเพื่อที่จะกลับเท็จแม้ที่คาดว่าจะ ค่า
ปัจจุบัน แต่รูปแบบที่อ่อนแอเป็นบางครั้งมีประสิทธิภาพมากขึ้นกว่ารุ่นที่แข็งแกร่ง
www.it-ebooks.info
18.7 อะตอม 1019
18.7.3 C-อินเตอร์เฟซแบบของอะตอม
สำหรับอะตอมข้อเสนอสำหรับ C + +, มีข้อเสนอที่สอดคล้องกันสำหรับ C ซึ่งควร ให้
ความหมายเหมือนกัน แต่อาจจะแน่นอนไม่ใช้ C + คุณสมบัติเฉพาะเช่น + เป็นแม่แบบการอ้างอิง
และการทำงานของสมาชิก ดังนั้นอินเตอร์เฟซของอะตอมทั้งหมดมีเทียบเท่า C แบบซึ่งยัง
ถูกเสนอเป็นส่วนขยายไปมาตรฐาน C
ตัวอย่างเช่นคุณยังสามารถประกาศอะตอมเป็น atomic_bool และแทนที่จะเก็บ ()
และโหลด () คุณสามารถใช้ฟังก์ชั่นระดับโลกซึ่งใช้ตัวชี้ไปยังวัตถุ:
std :: atomic_bool ข / / เทียบเท่ากับ: std :: อะตอมข
std :: atomic_init (และข, เท็จ) / / ดูส่วน 18.7.1, หน้า 1013
...
std :: atomic_store (และขจริง) / / เทียบเท่ากับ: ab.store (จริง)
...
ถ้า ( std :: atomic_load (และข)) {/ / เทียบเท่ากับ: ถ้า (ab.load ())
...
}
แต่ C เข้ามาติดต่ออื่นโดยใช้ _Atomic และ _Atomic () ดังนั้นอินเตอร์เฟซ C สไตล์
ทั่วไปเป็นประโยชน์ สำหรับรหัสที่จะต้องทั้ง C และ C + + compilable ในระยะใกล้
อย่างไรก็ตามการใช้ชนิดอะตอม C สไตล์เป็นเรื่องธรรมดาสวยใน C + + ตารางที่ 18.12 รายการที่สำคัญที่สุดที่
ชื่อประเภทอะตอม มีให้มากขึ้นสำหรับชนิดที่พบน้อยลงเช่น
atomic_int_fast32_t กับอะตอม.
โปรดทราบว่าสำหรับตัวชี้ที่ใช้ร่วมกัน (ดูมาตรา 5.2.1, หน้า 76) การดำเนินงานของอะตอมพิเศษที่มีให้
เหตุผลก็คือการประกาศเช่นอะตอม> เป็นไปไม่ได้เพราะที่ใช้ร่วมกัน
ไม่ได้เป็นตัวชี้ copyable นิด การดำเนินงานของอะตอมไปตามข้อตกลงการตั้งชื่อของซีสไตล์
อินเตอร์เฟซ ดูมาตรา 5.2.4, หน้า 96 สำหรับรายละเอียด
18.7.4 ต่ำระดับรูปแบบของอะตอม
อินเตอร์เฟซระดับต่ำของอะตอมหมายถึงการใช้การดำเนินงานของอะตอมในทางที่เราไม่มี
ความสอดคล้องต่อเนื่องรับประกัน ดังนั้นคอมไพเลอร์และฮาร์ดแวร์อาจ (บางส่วน) เรียงลำดับการเข้าถึง
ในอะตอม (ดูมาตรา 18.4.3, หน้า 986)
ระวังอีกครั้งแม้ว่าผมจะยกตัวอย่างพื้นที่นี้เป็นเขตที่วางทุ่นระเบิด คุณต้องการมากของความเชี่ยวชาญที่จะ
รู้ว่าเมื่อ reorderings หน่วยความจำที่คุ้มค่าความพยายามและผู้เชี่ยวชาญแม้มักจะทำผิดพลาดในเรื่องนี้
area.27
ผู้เชี่ยวชาญใช้คุณสมบัตินี้ควรจะคุ้นเคยกับวัสดุที่กล่าวถึงใน [N2480: MemMod]
และ [BoehmAdve: MemMod ] หรือโดยทั่วไปวัสดุทั้งหมดที่ระบุไว้ที่ [Boehm: C + + MM]
27 ขอขอบคุณเป็นพิเศษกับฮันส์ Boehm และ Bartosz Milewski สำหรับการสนับสนุนของพวกเขาในการให้ฉันเข้าใจในเรื่องนี้ของพวกเขาและ
ความช่วยเหลือในการให้บริการการใช้ถ้อยคำที่เหมาะสม ข้อบกพร่องใด ๆ เป็นความผิดของฉัน
www.it-ebooks.info
1020 บทที่ 18: Concurrency
ประเภทชื่อประเภทที่สอดคล้องกัน
atomic_bool อะตอม
atomic_char อะตอม
atomic_schar อะตอม
atomic_uchar อะตอม
atomic_short อะตอม
atomic_ushort อะตอม
atomic_int อะตอม
atomic_uint อะตอม
atomic_long อะตอม
atomic_ulong อะตอม
atomic_llong อะตอม
atomic_ullong อะตอม
atomic_char16_t อะตอม
atomic_char32_t อะตอม
atomic_wchar_t อะตอม
atomic_intptr_t อะตอม
atomic_uintptr_t อะตอม
atomic_size_t อะตอม
atomic_ptrdiff_t อะตอม
atomic_intmax_t อะตอม
atomic_uintmax_t อะตอม
ตารางที่ 18.12 บางประเภทของชื่อ std :: อะตอม <>
ตัวอย่างต่ำระดับรูปแบบของอะตอม
พิจารณาตัวอย่างที่สองสำหรับการใช้อะตอมแนะนำในมาตรา 18.7.1, หน้า 1014 ที่เรา
ประกาศธงอะตอมการควบคุมการเข้าถึงข้อมูลบางอย่าง :
ข้อมูลยาว
std :: อะตอมreadyFlag (เท็จ);
และด้ายให้ข้อมูล:
ข้อมูล = 42 / / ให้บางข้อมูล
readyFlag.store (จริง) / / และความพร้อมสัญญาณ
และด้ายบริโภคข้อมูล:
ในขณะที่ {(readyFlag.load ()) / / ห่วงจนพร้อมที่
...
}
std :: ศาล << ข้อมูล << std :: endl / / และขั้นตอนการให้ข้อมูล
เพราะเราใช้เพื่อเริ่มต้นหน่วยความจำซึ่งรับประกันความมั่นคงเรียงตามลำดับงานนี้เป็น
ที่อธิบายไว้ในมาตรา 18.7 1 หน้า 1015 ในความเป็นจริงสิ่งที่เราเรียกจริงๆ:
www.it-ebooks.info
18.7 อะตอม 1021
ข้อมูล = 42;
readyFlag.store (จริง std :: memory_order_seq_cst);
และ
ในขณะที่ {(readyFlag.load (std :: memory_order_seq_cst))
...
}
std :: ศาล << ข้อมูล << std :: endl;
ดังนั้นการดำเนินงานของแต่ละคนมีอาร์กิวเมนต์ตัวเลือกที่จะส่งคำสั่งซื้อหน่วยความจำซึ่งโดยปกติเป็น
std :: memory_order_seq_cst
การแปล กรุณารอสักครู่..
เรื่องบทที่ 18 : การดำเนินงานการ store()
การปล่อยในหน่วยความจำที่เรียกว่าผลกระทบสถานที่
ซึ่งโดยค่าเริ่มต้นเพื่อให้แน่ใจว่า ทั้งหมดก่อนที่หน่วยความจำปฏิบัติการ ว่า อะตอม หรือ ไม่ จะมองเห็น
กระทู้อื่นก่อนผลของร้านปฏิบัติการ .
ตามด้าย consumer() แสดงวงของ load() และกระบวนการข้อมูล แล้ว :
ในขณะที่ ! readyflag .load() ) { / / ห่วงจนพร้อม
.
}
std : : เคาท์ < < ข้อมูล < < std : : Endl ; / / กระบวนการให้ข้อมูลและการดำเนินงานมีประสิทธิภาพ load()
ที่เรียกว่าได้รับผ่าตัดมีผลต่อความจำสถานที่
ซึ่งโดยค่าเริ่มต้นเพื่อให้แน่ใจว่า ทั้งหมดต่อไปนี้การดำเนินงานหน่วยความจำว่า อะตอม หรือ ไม่ กลายเป็น
มองเห็นหัวข้ออื่น ๆ หลังจากโหลด
เป็นผลการดําเนินงานเนื่องจากการตั้งค่าของข้อมูลเกิดขึ้นก่อน provider() ร้านค้าจริง
readyflag และการประมวลผลของข้อมูลเกิดขึ้นหลังจากที่ consumer() ได้โหลดจริงเป็นค่า
ของ readyflag การประมวลผลข้อมูลมีการประกันที่จะเกิดขึ้นหลังจากที่ข้อมูลให้
รับประกันนี้ให้เพราะในการดำเนินการอะตอมทั้งหมด เราใช้ค่าหน่วยความจำ ชื่อ memory_order_seq_cst เพื่อ
,ซึ่งหมายถึงระบบที่สอดคล้องกันหน่วยความจำเพื่อ กับการเปลี่ยนแปลง
อะตอม เราสามารถที่จะผ่อนคลายนี้ เพื่อรับประกัน ( ดูมาตรา 1019 18.7.4 , หน้า , รายละเอียด
) 18.7.2 อะตอมและอินเตอร์เฟซในระดับอะตอมในรายละเอียด
< > แม่แบบห้อง std : : อะตอม < > มีความสามารถทั่วไปของประเภทข้อมูลอะตอม .
มันสามารถ จะใช้สำหรับการใด ๆไร้สาระประเภทชาญให้บูลทุกประเภทหนึ่งและตัวชี้ :
< T > แม่แบบ typename ซอฟต์แวร์อะตอม ; / / ประถมเรียน
< > ซอฟต์แวร์แม่แบบแม่แบบอะตอม < บูล > ; / / ชัดเจน specializations
< > ซอฟต์แวร์แม่แบบอะตอม < int > ;
.
t > < typename ซอฟต์แวร์แม่แบบอะตอม < t * ; / / ส่วนความเชี่ยวชาญเพื่อชี้
โต๊ะ 18.11 รายการระดับสูงปฏิบัติการให้อะตอม . ถ้าเป็นไปได้พวกเขาแผนที่โดยตรง
ที่ใช้ซีพียู คอลัมน์ triv ธงปฏิบัติการให้ std : : อะตอมอะตอม >
< บูลและของอื่นๆเล็กน้อยประเภท คอลัมน์ INT ประเภทธงปฏิบัติการให้ std : : อะตอม < > ,
ถ้าประเภทหนึ่งที่ใช้ และการใช้คอลัมน์ชนิดธงให้ std : : อะตอม < > ถ้า
ประเภทชี้คือ ใช้ คู่ของ ข้อสังเกตเกี่ยวกับ
หมายเหตุ ตารางนี้ :
- ทั่วไปการดำเนินงานผลผลิตชุดมากกว่าการอ้างอิง .
- จัดสร้างเริ่มต้นไม่ได้เริ่มต้นตัวแปร / วัตถุโดยสิ้นเชิง เพียงกฎหมายการผ่าตัด
หลังจากการก่อสร้างเริ่มต้นเรียก atomic_init() เพื่อเริ่มการทำงานของวัตถุ ( ดูมาตรา 18.7.1
, หน้า 1013 )
- คอนสตรัคสำหรับค่าของประเภทที่ไม่ใช่
อะตอม- ฟังก์ชั่นทั้งหมดยกเว้นก่อสร้างมีเพียบสำหรับระเหยและไม่ระเหย .
www.it-ebooks ข้อมูล
งาน 18.7 อะตอม 1017 triv INT ใช้ผล
อะตอมประเภท = วาล ใช่ ใช่ ใช่ initializes กับวาล ( ไม่ผ่าตัดอะตอมอะตอม
) ; atomic_init ( & , วาล ) ใช่ ใช่ ใช่ เหมือนกัน ( โดยไม่ atomic_init() , จะไม่สามารถใช้ is_lock_free()
A
) ใช่ ใช่ ใช่ จริง ถ้าไม่ได้ใช้
ชนิดภายในล็อค
a.store ( วาล ) ใช่ ใช่ ใช่ มอบหมายวาล ( ส่งกลับเป็นโมฆะ )
. load() ครับจะคัดลอกค่าของ
a.exchange ( วาล ) ใช่ ใช่ ใช่ ใช่ และส่งกลับสำเนาส่งวาลค่าเก่าของ
a.compare_exchange_strong ( exp , ใช่ ใช่ ใช่ ใช่ แคสงาน ( ดูด้านล่าง )
เดส )
a.compare_exchange_weak ( exp , ใช่ ใช่ ใช่ อ่อนแอ CAS ปฏิบัติการ
เดส )
= วาลครับกำหนดและส่งกลับสำเนาวาล
Aผู้ประกอบการ atomic() ครับจะคัดลอกค่าของ
a.fetch_add ( วาล ) ใช่ใช่อะตอม t = วาล ( จะคัดลอกค่าใหม่
) a.fetch_sub ( วาล ) ใช่ใช่อะตอม t = วาล ( จะคัดลอกค่าใหม่
)
= วาล ใช่ ใช่ เหมือน t.fetch_add ( วาล )
- = วาล ใช่ ใช่ เหมือน t.fetch_sub ( วาล )
, ใช่ ใช่ ใช่ โทร ( 1 ) t.fetch_add และส่งกลับสำเนาหรือ 1
. . . . . . . . ใช่ ใช่ ใช่ โทร ( 1 )
t.fetch_sub และส่งกลับสำเนาหรือ A-1
a.fetch_and ( วาล ) ใช่อะตอมเป็น& = วาล ( จะคัดลอกค่าใหม่
)
a.fetch_or ( วาล ) ใช่อะตอมเป็น | = วาล ( จะคัดลอกค่าใหม่
)
a.fetch_xor ( วาล ) ใช่อะตอมเป็น
= วาล ( จะคัดลอกค่าใหม่
a ) & = วาลครับเหมือน a.fetch_and ( วาล ) : | = วาลครับเหมือน a.fetch_or ( วาล )
A
= วาลครับเหมือน a.fetch_xor ( วาล )
โต๊ะ 18.11 . การดำเนินงานในระดับอะตอม www.it-ebooks ข้อมูล
.1018 บทที่ 18 : การ
ตัวอย่างเช่นอะตอม < int > ต่อไปนี้งานปฏิบัติการประกาศ namespace std { :
/ / ความเชี่ยวชาญของ std : : อะตอม < > int :
< > ซอฟต์แวร์แม่แบบอะตอม < int > {
สาธารณะ :
/ / ผู้ควบคุมงานธรรมดาไม่ได้ให้ :
อะตอม ( อะตอม = &ผู้ประกอบการทราบ& ) = ลบ ;
&อะตอม ( อะตอม ) = Const & ) ระเหย = ลบ ;
/ / แต่โอนเป็น int มีไว้ซึ่งสามารถส่งผ่านอาร์กิวเมนต์ :
1 ) = ( INT ) ระเหย noexcept ;
1 ) = ( int ) noexcept ;
. . . . . . .
} } ;
กับ is_lock_free() , คุณสามารถตรวจสอบว่าประเภทของอะตอมภายในใช้ล็อคเป็นอะตอม .
ถ้าคุณมีฮาร์ดแวร์ที่สนับสนุนพื้นเมืองสำหรับการดำเนินการอะตอม ( ซึ่งเป็นสิ่งจำเป็นสำหรับการใช้อะตอมในตัวจัดการสัญญาณ
)ทั้ง compare_exchange_strong() compare_exchange_weak() และเรียก compareand -
สลับ ( CAS ) งาน ซีพียูอะตอมนี้มักจะมีการเปรียบเทียบเนื้อหาของหน่วยความจำเพื่อให้
ที่ตั้งค่าและ ถ้าพวกเขาจะเหมือนกัน , แก้ไขเนื้อหาของสถานที่ความทรงจำ
ที่เป็นค่าที่ให้ใหม่ รับประกันได้ว่าค่าใหม่จะคำนวณบนพื้นฐานของข้อมูลที่ทันสมัย
ผลที่ได้คือสิ่งที่ชอบรหัสเทียมต่อไปนี้ :
( T &บูล compare_exchange_strong คาดว่า T ต้องการ )
{
ถ้า ( - > load() = = คาดว่า ) {
- > ร้าน ( ที่ต้องการ ) กลับจริง ;
;
} {
อีกคาดว่า = - >
load() ; กลับเท็จ ;
} } ดังนั้น ถ้าค่าได้รับการปรับปรุงโดยหัวข้ออื่นในขณะเดียวกันก็ส่งกลับเท็จด้วย
ค่าใหม่ที่คาดหวังแบบฟอร์มที่อ่อนแออาจ spuriously ล้มเหลวเพื่อที่จะส่งกลับเท็จ แม้คาดว่าค่า
ปัจจุบัน แต่รูปแบบ อ่อนแอ บางครั้งมีประสิทธิภาพมากขึ้นกว่ารุ่นแรง . .
www.it-ebooks ข้อมูลราคาที่ c-style 18.7.3 อะตอมแล้ว
สำหรับข้อเสนออินเตอร์เฟซของอะตอมอะตอมสำหรับ C , มีข้อเสนอที่เกี่ยวข้องกับ C ซึ่งให้ความหมายเดียวกัน
แต่สามารถ แน่นอนไม่ใช้เฉพาะ C คุณสมบัติเป็นแม่แบบอ้างอิง
และฟังก์ชันสมาชิก ดังนั้น อินเตอร์เฟซอะตอมทั้งหมดได้เทียบเท่า c-style ซึ่งยัง
ถูกเสนอเป็นส่วนขยายมาตรฐาน c .
ตัวอย่างเช่นคุณยังสามารถประกาศ > บูลอะตอม < เป็น atomic_bool แทน และ store()
load() , คุณสามารถใช้ฟังก์ชันทั่วโลกซึ่งใช้ตัวชี้ไปยังวัตถุ :
: : : atomic_bool AB ;/ / เทียบเท่า : std : : อะตอม < บูล > AB
std : : atomic_init ( & AB , เท็จ ) ; / / ดูส่วน 18.7.1 หน้า 1013
. .
: : : atomic_store ( & AB , true ) ; / / เทียบเท่า : ab.store ( จริง )
ถ้า std : : . . . . . . . atomic_load ( & AB ) ) { / / ถ้า ( เทียบเท่ากับ AB load() )
. .
}
แต่ C เพิ่มอินเตอร์เฟซอื่น ใช้ _atomic และ _atomic() ดังนั้น c-style
อินเตอร์เฟซในทั่วไปจะมีประโยชน์สำหรับรหัสที่ต้องทั้ง C และ C compilable ในใกล้ . .
แต่ใช้ c-style อะตอมชนิดค่อนข้างพบได้บ่อยในค . ตารางรายการที่สำคัญที่สุด 18.12
อะตอมประเภทชื่อ มีเพิ่มเติมให้ สำหรับชนิดที่พบน้อย เช่น
atomic_int_fast32_t สำหรับอะตอม < int_fast32_t > .
ข้อความที่ใช้ร่วมกัน ( ดูมาตรา 5.2.1 ชี้ ,หน้า 76 ) การดำเนินการอะตอมพิเศษให้
เหตุผลคือ การประกาศ เช่น อะตอม < shared_ptr < T > > เป็นไปไม่ได้ เพราะตัวชี้ที่แบ่งปัน
ไม่ใช่เล็กๆ น้อยๆ copyable . การดำเนินงานของอะตอมตามชื่อการประชุมของอินเตอร์เฟซ c-style
ดูส่วน 5.2.4 , หน้า 96 , รายละเอียด .
18.7.4 ระดับต่ำของการเชื่อมต่อของอะตอม
อินเตอร์เฟซระดับอะตอมหมายถึง การดำเนินงานของอะตอมในลักษณะที่เราไม่มี
รับประกันความสอดคล้องต่อเนื่องกัน ดังนั้นคอมไพเลอร์และฮาร์ดแวร์อาจ ( บางส่วน ) สั่งซื้อเข้าถึง
ในอะตอม ( ดูมาตรา 18.4.3 หน้า 986 ) .
ระวังอีกครั้ง ผมยกตัวอย่าง พื้นที่นี้เป็นเขตที่วางทุ่นระเบิด คุณต้องการมากของความเชี่ยวชาญ
รู้เมื่อ reorderings หน่วยความจำจะคุ้มค่าความพยายามและผู้เชี่ยวชาญแม้ทำผิดบ่อยในพื้นที่นี้
. 27
ผู้เชี่ยวชาญการใช้คุณลักษณะนี้ควรจะคุ้นเคยกับวัสดุที่กล่าวถึงใน [ n2480 : memmod ]
และ [ boehmadve : memmod ] หรือ ทั่วไป วัสดุทั้งหมดไว้ที่ [ โบม : C - ] .
27 ขอบคุณฮันส์ bartosz milewski โบม และ สำหรับการสนับสนุนของพวกเขาและพวกเขาช่วยให้ผมเข้าใจนี้
ในการให้ถ้อยคำที่เหมาะสม ข้อบกพร่องใด ๆ เป็นความผิดของฉัน .
www.it-ebooks ข้อมูล
1020 บทที่ 18 : การตั้งชื่อชนิดตามประเภท
< >
atomic_char บูล atomic_bool อะตอมอะตอมอะตอม < >
< ชาร์ atomic_schar ลงนาม Char >
< >
atomic_uchar อะตอม / ถ่าน atomic_short อะตอมสั้น >
< >
< / atomic_ushort อะตอมสั้น atomic_int อะตอม < int >
< / atomic_uint อะตอม INT >
< >
atomic_ulong ยาว atomic_long อะตอมอะตอม >
< / ยาวatomic_llong อะตอม < นาน >
< / atomic_ullong อะตอมนาน >
< >
atomic_char32_t char16_t atomic_char16_t อะตอมอะตอม < char32_t >
< >
atomic_intptr_t wchar_t atomic_wchar_t อะตอมอะตอม < intptr_t >
< >
atomic_size_t uintptr_t atomic_uintptr_t อะตอมอะตอม < size_t >
< >
atomic_intmax_t ptrdiff_t atomic_ptrdiff_t อะตอมอะตอม < intmax_t >
atomic_uintmax_t อะตอม < uintmax_t >
โต๊ะ 18.12 .บางชื่อประเภทของ std : : อะตอม < >
ตัวอย่างต่ำระดับอินเตอร์เฟซของอะตอม
พิจารณาสองตัวอย่างสำหรับการใช้อะตอม แนะนํา ในส่วน 18.7.1 หน้า 1 ที่เรา
ประกาศธงอะตอมเพื่อการควบคุมการเข้าถึงข้อมูลบางข้อมูลยาว :
;
STD : : อะตอม < > readyflag บูล ( FALSE ) ;
และด้ายให้ข้อมูล :
ข้อมูล = 42 ; / / ให้ข้อมูลบางอย่าง
readyflag เก็บจริง ( ) ; / /
ความพร้อมและสัญญาณและหัวข้อบริโภคข้อมูล :
ในขณะที่ ! readyflag . load() ) { / / ห่วงจนพร้อม
.
}
std : : เคาท์ < < ข้อมูล < < std : : Endl ; / / และกระบวนการให้ข้อมูล
เพราะเราใช้เพื่อเริ่มต้นหน่วย ซึ่งรับประกันความสอดคล้องต่อเนื่องกัน นี่เป็น
อธิบายในส่วน 18.7.1 หน้าพี่มี . ในความเป็นจริง สิ่งที่เราเรียกจริงๆคือ :
www.it-ebooks ข้อมูล
อะตอม 1021 ราคาข้อมูล = 42 ;
readyflag เก็บ ( True , std : :memory_order_seq_cst ) ;
( และในขณะที่ ! readyflag โหลด ( std : : memory_order_seq_cst ) ) {
. .
}
std : : เคาท์ < < ข้อมูล < < std : : Endl ;
ดังนั้นแต่ละขั้นตอนมีอาร์กิวเมนต์ตัวเลือกที่จะผ่านหน่วยความจำเรียบร้อย ซึ่งโดยค่าเริ่มต้นคือ
std : : memory_order_seq_cst
การปล่อยในหน่วยความจำที่เรียกว่าผลกระทบสถานที่
ซึ่งโดยค่าเริ่มต้นเพื่อให้แน่ใจว่า ทั้งหมดก่อนที่หน่วยความจำปฏิบัติการ ว่า อะตอม หรือ ไม่ จะมองเห็น
กระทู้อื่นก่อนผลของร้านปฏิบัติการ .
ตามด้าย consumer() แสดงวงของ load() และกระบวนการข้อมูล แล้ว :
ในขณะที่ ! readyflag .load() ) { / / ห่วงจนพร้อม
.
}
std : : เคาท์ < < ข้อมูล < < std : : Endl ; / / กระบวนการให้ข้อมูลและการดำเนินงานมีประสิทธิภาพ load()
ที่เรียกว่าได้รับผ่าตัดมีผลต่อความจำสถานที่
ซึ่งโดยค่าเริ่มต้นเพื่อให้แน่ใจว่า ทั้งหมดต่อไปนี้การดำเนินงานหน่วยความจำว่า อะตอม หรือ ไม่ กลายเป็น
มองเห็นหัวข้ออื่น ๆ หลังจากโหลด
เป็นผลการดําเนินงานเนื่องจากการตั้งค่าของข้อมูลเกิดขึ้นก่อน provider() ร้านค้าจริง
readyflag และการประมวลผลของข้อมูลเกิดขึ้นหลังจากที่ consumer() ได้โหลดจริงเป็นค่า
ของ readyflag การประมวลผลข้อมูลมีการประกันที่จะเกิดขึ้นหลังจากที่ข้อมูลให้
รับประกันนี้ให้เพราะในการดำเนินการอะตอมทั้งหมด เราใช้ค่าหน่วยความจำ ชื่อ memory_order_seq_cst เพื่อ
,ซึ่งหมายถึงระบบที่สอดคล้องกันหน่วยความจำเพื่อ กับการเปลี่ยนแปลง
อะตอม เราสามารถที่จะผ่อนคลายนี้ เพื่อรับประกัน ( ดูมาตรา 1019 18.7.4 , หน้า , รายละเอียด
) 18.7.2 อะตอมและอินเตอร์เฟซในระดับอะตอมในรายละเอียด
< > แม่แบบห้อง std : : อะตอม < > มีความสามารถทั่วไปของประเภทข้อมูลอะตอม .
มันสามารถ จะใช้สำหรับการใด ๆไร้สาระประเภทชาญให้บูลทุกประเภทหนึ่งและตัวชี้ :
< T > แม่แบบ typename ซอฟต์แวร์อะตอม ; / / ประถมเรียน
< > ซอฟต์แวร์แม่แบบแม่แบบอะตอม < บูล > ; / / ชัดเจน specializations
< > ซอฟต์แวร์แม่แบบอะตอม < int > ;
.
t > < typename ซอฟต์แวร์แม่แบบอะตอม < t * ; / / ส่วนความเชี่ยวชาญเพื่อชี้
โต๊ะ 18.11 รายการระดับสูงปฏิบัติการให้อะตอม . ถ้าเป็นไปได้พวกเขาแผนที่โดยตรง
ที่ใช้ซีพียู คอลัมน์ triv ธงปฏิบัติการให้ std : : อะตอมอะตอม >
< บูลและของอื่นๆเล็กน้อยประเภท คอลัมน์ INT ประเภทธงปฏิบัติการให้ std : : อะตอม < > ,
ถ้าประเภทหนึ่งที่ใช้ และการใช้คอลัมน์ชนิดธงให้ std : : อะตอม < > ถ้า
ประเภทชี้คือ ใช้ คู่ของ ข้อสังเกตเกี่ยวกับ
หมายเหตุ ตารางนี้ :
- ทั่วไปการดำเนินงานผลผลิตชุดมากกว่าการอ้างอิง .
- จัดสร้างเริ่มต้นไม่ได้เริ่มต้นตัวแปร / วัตถุโดยสิ้นเชิง เพียงกฎหมายการผ่าตัด
หลังจากการก่อสร้างเริ่มต้นเรียก atomic_init() เพื่อเริ่มการทำงานของวัตถุ ( ดูมาตรา 18.7.1
, หน้า 1013 )
- คอนสตรัคสำหรับค่าของประเภทที่ไม่ใช่
อะตอม- ฟังก์ชั่นทั้งหมดยกเว้นก่อสร้างมีเพียบสำหรับระเหยและไม่ระเหย .
www.it-ebooks ข้อมูล
งาน 18.7 อะตอม 1017 triv INT ใช้ผล
อะตอมประเภท = วาล ใช่ ใช่ ใช่ initializes กับวาล ( ไม่ผ่าตัดอะตอมอะตอม
) ; atomic_init ( & , วาล ) ใช่ ใช่ ใช่ เหมือนกัน ( โดยไม่ atomic_init() , จะไม่สามารถใช้ is_lock_free()
A
) ใช่ ใช่ ใช่ จริง ถ้าไม่ได้ใช้
ชนิดภายในล็อค
a.store ( วาล ) ใช่ ใช่ ใช่ มอบหมายวาล ( ส่งกลับเป็นโมฆะ )
. load() ครับจะคัดลอกค่าของ
a.exchange ( วาล ) ใช่ ใช่ ใช่ ใช่ และส่งกลับสำเนาส่งวาลค่าเก่าของ
a.compare_exchange_strong ( exp , ใช่ ใช่ ใช่ ใช่ แคสงาน ( ดูด้านล่าง )
เดส )
a.compare_exchange_weak ( exp , ใช่ ใช่ ใช่ อ่อนแอ CAS ปฏิบัติการ
เดส )
= วาลครับกำหนดและส่งกลับสำเนาวาล
Aผู้ประกอบการ atomic() ครับจะคัดลอกค่าของ
a.fetch_add ( วาล ) ใช่ใช่อะตอม t = วาล ( จะคัดลอกค่าใหม่
) a.fetch_sub ( วาล ) ใช่ใช่อะตอม t = วาล ( จะคัดลอกค่าใหม่
)
= วาล ใช่ ใช่ เหมือน t.fetch_add ( วาล )
- = วาล ใช่ ใช่ เหมือน t.fetch_sub ( วาล )
, ใช่ ใช่ ใช่ โทร ( 1 ) t.fetch_add และส่งกลับสำเนาหรือ 1
. . . . . . . . ใช่ ใช่ ใช่ โทร ( 1 )
t.fetch_sub และส่งกลับสำเนาหรือ A-1
a.fetch_and ( วาล ) ใช่อะตอมเป็น& = วาล ( จะคัดลอกค่าใหม่
)
a.fetch_or ( วาล ) ใช่อะตอมเป็น | = วาล ( จะคัดลอกค่าใหม่
)
a.fetch_xor ( วาล ) ใช่อะตอมเป็น
= วาล ( จะคัดลอกค่าใหม่
a ) & = วาลครับเหมือน a.fetch_and ( วาล ) : | = วาลครับเหมือน a.fetch_or ( วาล )
A
= วาลครับเหมือน a.fetch_xor ( วาล )
โต๊ะ 18.11 . การดำเนินงานในระดับอะตอม www.it-ebooks ข้อมูล
.1018 บทที่ 18 : การ
ตัวอย่างเช่นอะตอม < int > ต่อไปนี้งานปฏิบัติการประกาศ namespace std { :
/ / ความเชี่ยวชาญของ std : : อะตอม < > int :
< > ซอฟต์แวร์แม่แบบอะตอม < int > {
สาธารณะ :
/ / ผู้ควบคุมงานธรรมดาไม่ได้ให้ :
อะตอม ( อะตอม = &ผู้ประกอบการทราบ& ) = ลบ ;
&อะตอม ( อะตอม ) = Const & ) ระเหย = ลบ ;
/ / แต่โอนเป็น int มีไว้ซึ่งสามารถส่งผ่านอาร์กิวเมนต์ :
1 ) = ( INT ) ระเหย noexcept ;
1 ) = ( int ) noexcept ;
. . . . . . .
} } ;
กับ is_lock_free() , คุณสามารถตรวจสอบว่าประเภทของอะตอมภายในใช้ล็อคเป็นอะตอม .
ถ้าคุณมีฮาร์ดแวร์ที่สนับสนุนพื้นเมืองสำหรับการดำเนินการอะตอม ( ซึ่งเป็นสิ่งจำเป็นสำหรับการใช้อะตอมในตัวจัดการสัญญาณ
)ทั้ง compare_exchange_strong() compare_exchange_weak() และเรียก compareand -
สลับ ( CAS ) งาน ซีพียูอะตอมนี้มักจะมีการเปรียบเทียบเนื้อหาของหน่วยความจำเพื่อให้
ที่ตั้งค่าและ ถ้าพวกเขาจะเหมือนกัน , แก้ไขเนื้อหาของสถานที่ความทรงจำ
ที่เป็นค่าที่ให้ใหม่ รับประกันได้ว่าค่าใหม่จะคำนวณบนพื้นฐานของข้อมูลที่ทันสมัย
ผลที่ได้คือสิ่งที่ชอบรหัสเทียมต่อไปนี้ :
( T &บูล compare_exchange_strong คาดว่า T ต้องการ )
{
ถ้า ( - > load() = = คาดว่า ) {
- > ร้าน ( ที่ต้องการ ) กลับจริง ;
;
} {
อีกคาดว่า = - >
load() ; กลับเท็จ ;
} } ดังนั้น ถ้าค่าได้รับการปรับปรุงโดยหัวข้ออื่นในขณะเดียวกันก็ส่งกลับเท็จด้วย
ค่าใหม่ที่คาดหวังแบบฟอร์มที่อ่อนแออาจ spuriously ล้มเหลวเพื่อที่จะส่งกลับเท็จ แม้คาดว่าค่า
ปัจจุบัน แต่รูปแบบ อ่อนแอ บางครั้งมีประสิทธิภาพมากขึ้นกว่ารุ่นแรง . .
www.it-ebooks ข้อมูลราคาที่ c-style 18.7.3 อะตอมแล้ว
สำหรับข้อเสนออินเตอร์เฟซของอะตอมอะตอมสำหรับ C , มีข้อเสนอที่เกี่ยวข้องกับ C ซึ่งให้ความหมายเดียวกัน
แต่สามารถ แน่นอนไม่ใช้เฉพาะ C คุณสมบัติเป็นแม่แบบอ้างอิง
และฟังก์ชันสมาชิก ดังนั้น อินเตอร์เฟซอะตอมทั้งหมดได้เทียบเท่า c-style ซึ่งยัง
ถูกเสนอเป็นส่วนขยายมาตรฐาน c .
ตัวอย่างเช่นคุณยังสามารถประกาศ > บูลอะตอม < เป็น atomic_bool แทน และ store()
load() , คุณสามารถใช้ฟังก์ชันทั่วโลกซึ่งใช้ตัวชี้ไปยังวัตถุ :
: : : atomic_bool AB ;/ / เทียบเท่า : std : : อะตอม < บูล > AB
std : : atomic_init ( & AB , เท็จ ) ; / / ดูส่วน 18.7.1 หน้า 1013
. .
: : : atomic_store ( & AB , true ) ; / / เทียบเท่า : ab.store ( จริง )
ถ้า std : : . . . . . . . atomic_load ( & AB ) ) { / / ถ้า ( เทียบเท่ากับ AB load() )
. .
}
แต่ C เพิ่มอินเตอร์เฟซอื่น ใช้ _atomic และ _atomic() ดังนั้น c-style
อินเตอร์เฟซในทั่วไปจะมีประโยชน์สำหรับรหัสที่ต้องทั้ง C และ C compilable ในใกล้ . .
แต่ใช้ c-style อะตอมชนิดค่อนข้างพบได้บ่อยในค . ตารางรายการที่สำคัญที่สุด 18.12
อะตอมประเภทชื่อ มีเพิ่มเติมให้ สำหรับชนิดที่พบน้อย เช่น
atomic_int_fast32_t สำหรับอะตอม < int_fast32_t > .
ข้อความที่ใช้ร่วมกัน ( ดูมาตรา 5.2.1 ชี้ ,หน้า 76 ) การดำเนินการอะตอมพิเศษให้
เหตุผลคือ การประกาศ เช่น อะตอม < shared_ptr < T > > เป็นไปไม่ได้ เพราะตัวชี้ที่แบ่งปัน
ไม่ใช่เล็กๆ น้อยๆ copyable . การดำเนินงานของอะตอมตามชื่อการประชุมของอินเตอร์เฟซ c-style
ดูส่วน 5.2.4 , หน้า 96 , รายละเอียด .
18.7.4 ระดับต่ำของการเชื่อมต่อของอะตอม
อินเตอร์เฟซระดับอะตอมหมายถึง การดำเนินงานของอะตอมในลักษณะที่เราไม่มี
รับประกันความสอดคล้องต่อเนื่องกัน ดังนั้นคอมไพเลอร์และฮาร์ดแวร์อาจ ( บางส่วน ) สั่งซื้อเข้าถึง
ในอะตอม ( ดูมาตรา 18.4.3 หน้า 986 ) .
ระวังอีกครั้ง ผมยกตัวอย่าง พื้นที่นี้เป็นเขตที่วางทุ่นระเบิด คุณต้องการมากของความเชี่ยวชาญ
รู้เมื่อ reorderings หน่วยความจำจะคุ้มค่าความพยายามและผู้เชี่ยวชาญแม้ทำผิดบ่อยในพื้นที่นี้
. 27
ผู้เชี่ยวชาญการใช้คุณลักษณะนี้ควรจะคุ้นเคยกับวัสดุที่กล่าวถึงใน [ n2480 : memmod ]
และ [ boehmadve : memmod ] หรือ ทั่วไป วัสดุทั้งหมดไว้ที่ [ โบม : C - ] .
27 ขอบคุณฮันส์ bartosz milewski โบม และ สำหรับการสนับสนุนของพวกเขาและพวกเขาช่วยให้ผมเข้าใจนี้
ในการให้ถ้อยคำที่เหมาะสม ข้อบกพร่องใด ๆ เป็นความผิดของฉัน .
www.it-ebooks ข้อมูล
1020 บทที่ 18 : การตั้งชื่อชนิดตามประเภท
< >
atomic_char บูล atomic_bool อะตอมอะตอมอะตอม < >
< ชาร์ atomic_schar ลงนาม Char >
< >
atomic_uchar อะตอม / ถ่าน atomic_short อะตอมสั้น >
< >
< / atomic_ushort อะตอมสั้น atomic_int อะตอม < int >
< / atomic_uint อะตอม INT >
< >
atomic_ulong ยาว atomic_long อะตอมอะตอม >
< / ยาวatomic_llong อะตอม < นาน >
< / atomic_ullong อะตอมนาน >
< >
atomic_char32_t char16_t atomic_char16_t อะตอมอะตอม < char32_t >
< >
atomic_intptr_t wchar_t atomic_wchar_t อะตอมอะตอม < intptr_t >
< >
atomic_size_t uintptr_t atomic_uintptr_t อะตอมอะตอม < size_t >
< >
atomic_intmax_t ptrdiff_t atomic_ptrdiff_t อะตอมอะตอม < intmax_t >
atomic_uintmax_t อะตอม < uintmax_t >
โต๊ะ 18.12 .บางชื่อประเภทของ std : : อะตอม < >
ตัวอย่างต่ำระดับอินเตอร์เฟซของอะตอม
พิจารณาสองตัวอย่างสำหรับการใช้อะตอม แนะนํา ในส่วน 18.7.1 หน้า 1 ที่เรา
ประกาศธงอะตอมเพื่อการควบคุมการเข้าถึงข้อมูลบางข้อมูลยาว :
;
STD : : อะตอม < > readyflag บูล ( FALSE ) ;
และด้ายให้ข้อมูล :
ข้อมูล = 42 ; / / ให้ข้อมูลบางอย่าง
readyflag เก็บจริง ( ) ; / /
ความพร้อมและสัญญาณและหัวข้อบริโภคข้อมูล :
ในขณะที่ ! readyflag . load() ) { / / ห่วงจนพร้อม
.
}
std : : เคาท์ < < ข้อมูล < < std : : Endl ; / / และกระบวนการให้ข้อมูล
เพราะเราใช้เพื่อเริ่มต้นหน่วย ซึ่งรับประกันความสอดคล้องต่อเนื่องกัน นี่เป็น
อธิบายในส่วน 18.7.1 หน้าพี่มี . ในความเป็นจริง สิ่งที่เราเรียกจริงๆคือ :
www.it-ebooks ข้อมูล
อะตอม 1021 ราคาข้อมูล = 42 ;
readyflag เก็บ ( True , std : :memory_order_seq_cst ) ;
( และในขณะที่ ! readyflag โหลด ( std : : memory_order_seq_cst ) ) {
. .
}
std : : เคาท์ < < ข้อมูล < < std : : Endl ;
ดังนั้นแต่ละขั้นตอนมีอาร์กิวเมนต์ตัวเลือกที่จะผ่านหน่วยความจำเรียบร้อย ซึ่งโดยค่าเริ่มต้นคือ
std : : memory_order_seq_cst
การแปล กรุณารอสักครู่..
ภาษาอื่น ๆ
การสนับสนุนเครื่องมือแปลภาษา: กรีก, กันนาดา, กาลิเชียน, คลิงออน, คอร์สิกา, คาซัค, คาตาลัน, คินยารวันดา, คีร์กิซ, คุชราต, จอร์เจีย, จีน, จีนดั้งเดิม, ชวา, ชิเชวา, ซามัว, ซีบัวโน, ซุนดา, ซูลู, ญี่ปุ่น, ดัตช์, ตรวจหาภาษา, ตุรกี, ทมิฬ, ทาจิก, ทาทาร์, นอร์เวย์, บอสเนีย, บัลแกเรีย, บาสก์, ปัญจาป, ฝรั่งเศส, พาชตู, ฟริเชียน, ฟินแลนด์, ฟิลิปปินส์, ภาษาอินโดนีเซี, มองโกเลีย, มัลทีส, มาซีโดเนีย, มาราฐี, มาลากาซี, มาลายาลัม, มาเลย์, ม้ง, ยิดดิช, ยูเครน, รัสเซีย, ละติน, ลักเซมเบิร์ก, ลัตเวีย, ลาว, ลิทัวเนีย, สวาฮิลี, สวีเดน, สิงหล, สินธี, สเปน, สโลวัก, สโลวีเนีย, อังกฤษ, อัมฮาริก, อาร์เซอร์ไบจัน, อาร์เมเนีย, อาหรับ, อิกโบ, อิตาลี, อุยกูร์, อุสเบกิสถาน, อูรดู, ฮังการี, ฮัวซา, ฮาวาย, ฮินดี, ฮีบรู, เกลิกสกอต, เกาหลี, เขมร, เคิร์ด, เช็ก, เซอร์เบียน, เซโซโท, เดนมาร์ก, เตลูกู, เติร์กเมน, เนปาล, เบงกอล, เบลารุส, เปอร์เซีย, เมารี, เมียนมา (พม่า), เยอรมัน, เวลส์, เวียดนาม, เอสเปอแรนโต, เอสโทเนีย, เฮติครีโอล, แอฟริกา, แอลเบเนีย, โคซา, โครเอเชีย, โชนา, โซมาลี, โปรตุเกส, โปแลนด์, โยรูบา, โรมาเนีย, โอเดีย (โอริยา), ไทย, ไอซ์แลนด์, ไอร์แลนด์, การแปลภาษา.
- Project Integration The fish mix chicken
- He sent you a gift Cod (Cash On Delivery
- Coffee Cup Experiment
- สังคม
- cat
- ฉันเหนื่อย แต่ก็ไม่ลืม ถ่ายภาพ และ ตกแต่
- รองเท้าคัทชู
- ฉันกลัวตัวเองจะข่มขืนคุณ
- ตั้งใจทำงาน
- Friends can help each other. A true frie
- I seen Harry potter 1st and 2nd movie
- The first class You learn to write in Th
- ทีมวิศวกรรม, โปรดพิจารณาเพื่อแก้ไขปัญหาค
- really
- 愛しています
- Del chicken as weeds grow in every seaso
- administrator
- เชียงราย
- แต่คะแนนจะดีหรือไม่ ฉันไม่รู้
- หาความสุข
- นักท่องเที่ยวที่เคยมาเที่ยวที่นี้แล้วมีค
- modesty
- ผมคิดว่าจหหยุดเล่น
- I understand, but I rarely use English p
