18.3 Starting a Thread in Detail 97

18.3 Starting a Thread in Detail 979
Operation Effect
packaged_task pt Default constructor; creates a packaged task with
no shared state and no stored task
packaged_task pt(f) Creates an object for the task f
packaged_task pt(alloc,f) Creates an object for the task f using allocator
alloc
packaged_task pt(rv) Move constructor; moves the packaged task rv
(task and state) to pt (rv has no shared state
afterward)
pt.~packaged_task() Destroys *this (might make shared state ready)
pt = rv Move assignment; move assigns the packaged
task rv (task and state) to pt (rv has no shared
state afterward)
swap(pt1,pt2) Swaps packaged tasks
pt1.swap(pt2) Swaps packaged tasks
pt.valid() Yields true if pt has a shared state
pt.get_future() Yields a future object to retrieve the shared state
(outcome of the task)
pt(args) Calls the task (with optional arguments) and
makes the shared state ready
pt.make_ready_at_thread_exit(args) Calls the task (with optional arguments) and at
thread exit makes the shared state ready
pt.reset() Creates a new shared state for pt (might make
the old shared state ready)
Table 18.3. Operations of Class packaged_task
18.3.6 Class std::thread in Detail
An object of class std::thread, introduced in Section 18.2.1, page 964, is provided to start and
represent a thread. These objects are intended to map one-to-one with threads provided by the
operating system. Table 18.4 lists the operations available for class thread.
The association between a thread object and a thread starts by initializing (or move copy/assign)
a callable object (see Section 4.4, page 54) to it with optional additional arguments. The association
ends either with join() (waiting for the outcome of the thread) or with detach() (explicitly losing
the association to the thread). One or the other must be called before the lifetime of a thread object
ends or a new thread gets move assigned. Otherwise, the program aborts with std::terminate()
(see Section 5.8.2, page 162).
If the thread object has an associated thread, it is said to be joinable. In that case, joinable()
yields true, and get_id() yields a thread ID that differs from std::thread::id().
Thread IDs have their own type std::thread::id. Its default constructor yields a unique ID
representing “no thread.” thread::get_id() yields this value if no thread is associated or another
unique ID if the thread object is associated with a thread (is joinable). The only supported operations
www.it-ebooks.info
980 Chapter 18: Concurrency
Operation Effect
thread t Default constructor; creates a nonjoinable thread object
thread t(f,...) Creates a thread object, representing f started as thread (with
additional args), or throws std::system_error
thread t(rv) Move constructor; creates a new thread object, which gets the state of
rv, and makes rv nonjoinable
t.~thread() Destroys *this; calls std::terminate() if the object is joinable
t = rv Move assignment; move assigns the state of rv to t or calls
std::terminate() if t is joinable
t.joinable() Yields true if t has an associated thread (is joinable)
t.join() Waits for the associated thread to finish (throws std::system_error
if the thread is not joinable) and makes the object nonjoinable
t.detach() Releases the association of t to its thread while the thread continues
(throws std::system_error if the thread is not joinable) and makes
the object nonjoinable
t.get_id() Returns a unique std::thread::id if joinable or
std::thread::id() if not
t.native_handle() Returns a platform-specific type native_handle_type for
nonportable extensions
Table 18.4. Operations of Objects of Class thread
for thread IDs are to compare them or to write them to an output stream. In addition, a hash function
is provided to manage thread IDs in unordered containers (see Section 7.9, page 356). A thread ID
of a terminated thread might be reused again. Don’t make any other assumptions about thread IDs
other than that, especially regarding their values. See Section 18.2.1, page 968, for details.
Note that detached threads should not access objects whose lifetimes have ended. This implies
the problem that when ending the program, you have to ensure that detached threads don’t access
global/static objects (see Section 18.2.1, page 967).
In addition, class std::thread provides a static member function to query a hint for the possible
number of parallel threads:
unsigned int std::thread::hardware_concurrency ()
• Returns the number of possible threads.
• This value is just a hint and does not guarantee to be exact.
• Returns 0 if the number is not computable or well defined.
www.it-ebooks.info
18.3 Starting a Thread in Detail 981
18.3.7 Namespace this_thread
For any thread, including the main thread, declares namespace std::this_thread,
which provides the thread-specific global functions listed in Table 18.5.
Operation Effect
this_thread::get_id() Yields the ID of the current thread
this_thread::sleep_for(dur) Blocks the thread for duration dur
this_thread::sleep_until(tp) Blocks the thread until timepoint tp
this_thread::yield() Hint to reschedule to the next thread
Table 18.5. Thread-Specific Operations of Namespace std::this_thread
Note that sleep_for() and sleep_until() usually will differ when dealing with system-time
adjustments (see Section 5.7.5, page 160, for details).
The operation this_thread::yield() is provided to give a hint to the system that it is useful
to give up the remainder of the current thread’s time slice so that the runtime environment can
reschedule to allow other threads to run. One typical example is to give up control when you wait or
“poll” for another thread (see Section 18.1.1, page 955) or an atomic flag to be set by another thread
(see Section 18.4.3, page 986):11
while (!readyFlag) { // loop until data is ready
std::this_thread::yield();
}
As another example, when you fail to get a lock or a mutex while locking multiple locks/mutexes at
a time, you can make the application faster by using yield() prior to trying the locks/mutexes in a
different order.12
11 Thanks to Bartosz Milewski for this example.
12 Thanks to Howard Hinnant for this example.
www.it-ebooks.info
982 Chapter 18: Concurrency
18.4 Synchronizing Threads, or the Problem of
Concurrency
Using multiple threads is almost always combined with concurrent data access. Rarely are multiple
threads run independently of one another. Threads might provide data processed by other threads or
prepare preconditions necessary to start other processes.
This is where multithreading becomes tricky. Many things can go wrong. Or, put another way,
many things can behave differently from what the naive (and even the experienced) programmer
might expect.
So, before discussing different ways to synchronize threads and concurrent data access, we have
to understand the problem. Then we can discuss the following techniques to synchronize threads:
• 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.4.1 Beware of Concurrency!
Before discussing the details of the problems of concurrency, let me formulate a first rule just in case
you want to start programming without going into the depth of this subsection. If you learn one rule
about dealing with multiple threads, it should be the following:
The only safe way to concurrently access the same data by multiple threads without
synchronization is when ALL threads only READ the data.
By “the same data” I mean data that uses the same memory location. If different threads concurrently
access different variables or objects or different members of them, there is no problem because, since
C++11, each variable except a bitfield is guaranteed to have its own memory location.13 The only
exceptions are bitfields, because different bitfields might share a memory location so that accessing
different bitfields means shared access of the same data.
However, when two or more threads concurrently access the same variable or object or member
of it and at least one of the threads performs modifications, you can easily get into deep trouble if
you don’t synchronize that access. This is what is called a data race in C++. In the C++11 standard,
a data race is defined as “two conflicting actions in different threads, at least one of which is not
atomic, and neither happens before the other.” A data race always results in undefined behavior.
As always with race conditions, the problem is that your code might often do what you intended,
but it will not always work, which is one of the nastiest problems we can face in programming. Just
by using other data, going into production mode, or switching a platform might suddenly break your
code. So it’s probably a good idea to care about concurrent data access if you use multiple threads.
13 The guarantee of separate memory locations for different objects was not given before C++11. C++98/C++03
was a standard for single-threaded applications only. So, strictly speaking, before C++11 concurrent access to
different objects resulted in undefined behavior, although in practice it usually caused no problems.
www.it-ebooks.info

18.3 Starting a Thread in Detail 979
Operation Effect
packaged_task pt Default constructor; creates a packaged task with
no shared state and no stored task
packaged_task pt(f) Creates an object for the task f
packaged_task pt(alloc,f) Creates an object for the task f using allocator
alloc
packaged_task pt(rv) Move constructor; moves the packaged task rv
(task and state) to pt (rv has no shared state
afterward)
pt.~packaged_task() Destroys *this (might make shared state ready)
pt = rv Move assignment; move assigns the packaged
task rv (task and state) to pt (rv has no shared
state afterward)
swap(pt1,pt2) Swaps packaged tasks
pt1.swap(pt2) Swaps packaged tasks
pt.valid() Yields true if pt has a shared state
pt.get_future() Yields a future object to retrieve the shared state
(outcome of the task)
pt(args) Calls the task (with optional arguments) and
makes the shared state ready
pt.make_ready_at_thread_exit(args) Calls the task (with optional arguments) and at
thread exit makes the shared state ready
pt.reset() Creates a new shared state for pt (might make
the old shared state ready)
Table 18.3. Operations of Class packaged_task
18.3.6 Class std::thread in Detail
An object of class std::thread, introduced in Section 18.2.1, page 964, is provided to start and
represent a thread. These objects are intended to map one-to-one with threads provided by the
operating system. Table 18.4 lists the operations available for class thread.
The association between a thread object and a thread starts by initializing (or move copy/assign)
a callable object (see Section 4.4, page 54) to it with optional additional arguments. The association
ends either with join() (waiting for the outcome of the thread) or with detach() (explicitly losing
the association to the thread). One or the other must be called before the lifetime of a thread object
ends or a new thread gets move assigned. Otherwise, the program aborts with std::terminate()
(see Section 5.8.2, page 162).
If the thread object has an associated thread, it is said to be joinable. In that case, joinable()
yields true, and get_id() yields a thread ID that differs from std::thread::id().
Thread IDs have their own type std::thread::id. Its default constructor yields a unique ID
representing “no thread.” thread::get_id() yields this value if no thread is associated or another
unique ID if the thread object is associated with a thread (is joinable). The only supported operations
www.it-ebooks.info
980 Chapter 18: Concurrency
Operation Effect
thread t Default constructor; creates a nonjoinable thread object
thread t(f,...) Creates a thread object, representing f started as thread (with
additional args), or throws std::system_error
thread t(rv) Move constructor; creates a new thread object, which gets the state of
rv, and makes rv nonjoinable
t.~thread() Destroys *this; calls std::terminate() if the object is joinable
t = rv Move assignment; move assigns the state of rv to t or calls
std::terminate() if t is joinable
t.joinable() Yields true if t has an associated thread (is joinable)
t.join() Waits for the associated thread to finish (throws std::system_error
if the thread is not joinable) and makes the object nonjoinable
t.detach() Releases the association of t to its thread while the thread continues
(throws std::system_error if the thread is not joinable) and makes
the object nonjoinable
t.get_id() Returns a unique std::thread::id if joinable or
std::thread::id() if not
t.native_handle() Returns a platform-specific type native_handle_type for
nonportable extensions
Table 18.4. Operations of Objects of Class thread
for thread IDs are to compare them or to write them to an output stream. In addition, a hash function
is provided to manage thread IDs in unordered containers (see Section 7.9, page 356). A thread ID
of a terminated thread might be reused again. Don’t make any other assumptions about thread IDs
other than that, especially regarding their values. See Section 18.2.1, page 968, for details.
Note that detached threads should not access objects whose lifetimes have ended. This implies
the problem that when ending the program, you have to ensure that detached threads don’t access
global/static objects (see Section 18.2.1, page 967).
In addition, class std::thread provides a static member function to query a hint for the possible
number of parallel threads:
unsigned int std::thread::hardware_concurrency ()
• Returns the number of possible threads.
• This value is just a hint and does not guarantee to be exact.
• Returns 0 if the number is not computable or well defined.
www.it-ebooks.info
18.3 Starting a Thread in Detail 981
18.3.7 Namespace this_thread
For any thread, including the main thread,  declares namespace std::this_thread,
which provides the thread-specific global functions listed in Table 18.5.
Operation Effect
this_thread::get_id() Yields the ID of the current thread
this_thread::sleep_for(dur) Blocks the thread for duration dur
this_thread::sleep_until(tp) Blocks the thread until timepoint tp
this_thread::yield() Hint to reschedule to the next thread
Table 18.5. Thread-Specific Operations of Namespace std::this_thread
Note that sleep_for() and sleep_until() usually will differ when dealing with system-time
adjustments (see Section 5.7.5, page 160, for details).
The operation this_thread::yield() is provided to give a hint to the system that it is useful
to give up the remainder of the current thread’s time slice so that the runtime environment can
reschedule to allow other threads to run. One typical example is to give up control when you wait or
“poll” for another thread (see Section 18.1.1, page 955) or an atomic flag to be set by another thread
(see Section 18.4.3, page 986):11
while (!readyFlag) { // loop until data is ready
std::this_thread::yield();
}
As another example, when you fail to get a lock or a mutex while locking multiple locks/mutexes at
a time, you can make the application faster by using yield() prior to trying the locks/mutexes in a
different order.12
11 Thanks to Bartosz Milewski for this example.
12 Thanks to Howard Hinnant for this example.
www.it-ebooks.info
982 Chapter 18: Concurrency
18.4 Synchronizing Threads, or the Problem of
Concurrency
Using multiple threads is almost always combined with concurrent data access. Rarely are multiple
threads run independently of one another. Threads might provide data processed by other threads or
prepare preconditions necessary to start other processes.
This is where multithreading becomes tricky. Many things can go wrong. Or, put another way,
many things can behave differently from what the naive (and even the experienced) programmer
might expect.
So, before discussing different ways to synchronize threads and concurrent data access, we have
to understand the problem. Then we can discuss the following techniques to synchronize threads:
• 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.4.1 Beware of Concurrency!
Before discussing the details of the problems of concurrency, let me formulate a first rule just in case
you want to start programming without going into the depth of this subsection. If you learn one rule
about dealing with multiple threads, it should be the following:
The only safe way to concurrently access the same data by multiple threads without
synchronization is when ALL threads only READ the data.
By “the same data” I mean data that uses the same memory location. If different threads concurrently
access different variables or objects or different members of them, there is no problem because, since
C++11, each variable except a bitfield is guaranteed to have its own memory location.13 The only
exceptions are bitfields, because different bitfields might share a memory location so that accessing
different bitfields means shared access of the same data.
However, when two or more threads concurrently access the same variable or object or member
of it and at least one of the threads performs modifications, you can easily get into deep trouble if
you don’t synchronize that access. This is what is called a data race in C++. In the C++11 standard,
a data race is defined as “two conflicting actions in different threads, at least one of which is not
atomic, and neither happens before the other.” A data race always results in undefined behavior.
As always with race conditions, the problem is that your code might often do what you intended,
but it will not always work, which is one of the nastiest problems we can face in programming. Just
by using other data, going into production mode, or switching a platform might suddenly break your
code. So it’s probably a good idea to care about concurrent data access if you use multiple threads.
13 The guarantee of separate memory locations for different objects was not given before C++11. C++98/C++03
was a standard for single-threaded applications only. So, strictly speaking, before C++11 concurrent access to
different objects resulted in undefined behavior, although in practice it usually caused no problems.
www.it-ebooks.info

0/5000

จาก: -

เป็น: -

ผลลัพธ์ (ไทย) 1: [สำเนา]

คัดลอก!

ยัง 18.3 เริ่มเธรด 979 รายละเอียด
ผลการดำเนินงาน
packaged_task pt เริ่มต้นตัวสร้าง สร้างงานบรรจุด้วย
รัฐไม่ใช้ร่วมกันและไม่เก็บงาน
packaged_task pt(f) สร้างวัตถุสำหรับ f งาน
packaged_task pt(alloc,f) สร้างวัตถุสำหรับ f งานที่ใช้ตัวจัดสรร
ปันส่วนถึงวัน
packaged_task pt(rv) ย้ายตัวสร้าง ย้ายการบรรจุงาน rv
(งานและสถานะ) กับ pt (state
afterward)
pt.~packaged_task() ใช้ร่วมกันไม่มี rv Destroys * นี้ (อาจทำให้รัฐร่วมพร้อม)
pt = rv ย้ายกำหนด ย้ายกำหนดที่บรรจุ
งาน rv (งานและสถานะ) pt (ไม่ใช้ร่วมกันมี rv
รัฐ afterward)
swap(pt1,pt2) Swaps tasks
pt1.swap(pt2) บรรจุ Swaps tasks
pt.valid() บรรจุอัตราผลตอบแทนจริงถ้า pt รัฐร่วม
ptget_future() ทำให้วัตถุในอนาคตเรียกรัฐร่วม
(ผลของ task)
pt(args) การเรียกใช้งาน (กับอาร์กิวเมนต์ที่ไม่จำเป็น) และ
ทำให้ ready
pt.make_ready_at_thread_exit(args) รัฐร่วมเรียกใช้งาน (มีอาร์กิวเมนต์ที่ไม่จำเป็น) และที่
ทำออกด้ายที่ ready
pt.reset() รัฐร่วมสร้างใหม่ร่วมรัฐสำหรับ pt (อาจทำให้
เก่าร่วมรัฐพร้อม)
ยัง 18.3 ตาราง การดำเนินงานของคลาส packaged_task <>
18.3.6 คลา std::thread ละเอียด
วัตถุของคลา std::thread ในส่วน 18.2.1 หน้า 964 ให้เริ่ม และ
แทนเธรด วัตถุเหล่านี้มีวัตถุประสงค์เพื่อแมปแบบหนึ่งต่อหนึ่ง ด้วยโดยหัวข้อการ
ระบบปฏิบัติการ 18.4 ตารางแสดงรายการการดำเนินงานพร้อมใช้งานสำหรับเธรดระดับ
ความสัมพันธ์ระหว่างวัตถุเธรดและเธรดที่เริ่มต้น โดยเริ่มต้น (หรือย้ายคัดลอก/กำหนด)
ที่ callable วัตถุ (โปรดดูส่วน 4.4 หน้า 54) จะมีอาร์กิวเมนต์ตัวเลือกเพิ่มเติม สมาคม
สิ้นสุดอย่างใดอย่างหนึ่ง กับ join() (รอผลของเธรด) หรือ detach() (แพ้ชัดเจน
ความสัมพันธ์กับหัวข้อ) อีกอย่างหนึ่งต้องถูกเรียกก่อนอายุการใช้งานของวัตถุด้าย
ปลายหรือหัวข้อใหม่ได้กำหนดให้ย้าย มิฉะนั้น โปรแกรม aborts กับ std::terminate ()
(see Section 5.8.2, page 162).
ถ้าวัตถุหัวข้อมีหัวข้อเกี่ยวข้อง จึงกล่าวได้ว่า เป็น joinable ใน()ว่ากรณี joinable
จริงอัตราผลตอบแทน และ get_id() ทำให้ ID ของเธรดที่แตกต่างจาก std::thread::id().
หัวข้อรหัส std::thread::id ชนิดของตนเองได้ ตัวสร้างการเริ่มต้นทำให้รหัสเฉพาะ
แทน "ไม่ด้าย." หัวข้อ:: get_id() ทำให้ค่านี้หากไม่ด้าย หรืออื่น
ID เฉพาะหากวัตถุหัวข้อเกี่ยวข้องกับเธรด (คือ joinable) สนับสนุนการดำเนินงานเฉพาะ
www.it-ebooks.info
980 บท 18: เกิด
ผลการดำเนินงาน
ด้าย t เริ่มต้นตัวสร้าง สร้างวัตถุรูปด้าย nonjoinable
t(f,...) หัวข้อ สร้างวัตถุด้าย แทน f เป็นเธรด (ด้วย
อาร์กิวเมนต์เพิ่มเติม), หรือพ่น std::system_error
ด้าย t(rv) ย้ายตัวสร้าง สร้างวัตถุหัวข้อใหม่ ซึ่งได้รับสถานะของ
rv และทำให้ rv nonjoinable
t.~thread() ทำลาย * นี้ เรียก std::terminate() ว่าวัตถุ joinable
t = rv ย้ายกำหนด ย้ายกำหนดสถานะของ rv t หรือเรียก
std::terminate() ถ้า t joinable
t.joinable() ทำให้จริงถ้าไม่มีหัวข้อเกี่ยวข้อง (เป็น joinable)
t.join() รอหัวข้อเชื่อมโยงเสร็จสิ้น (พ่น std::system_error
ว่าเธรดไม่ joinable) และทำให้ nonjoinable
t.detach() วัตถุออกสมาคม t กับด้ายในขณะที่เธรดยังคง
(throws std::system_error ว่าเธรดไม่ joinable) และทำให้
nonjoinable
t.get_id() วัตถุส่งกลับ std::thread::id เฉพาะถ้า joinable หรือ
std::thread::id() ถ้า native_handle_type แพลตฟอร์มเฉพาะชนิดการส่งคืน not
t.native_handle()
นามสกุล nonportable
18.4 ตาราง การดำเนินงานของเธรดวัตถุคลาส
สำหรับเธรด รหัสเป็น การเปรียบเทียบ หรือ เพื่อเขียนการกระแสข้อมูลขาออก นอกจากนี้ ฟังก์ชันแฮช
ไว้ไปจัดการหัวข้อรหัสในภาชนะปกติ (ดูส่วน 7.9 หน้า 356) ID หัวข้อ
ของเธรดหยุดชะงักอาจจะนำกลับมาใช้อีกได้ ไม่ทำให้สมมติฐานอื่น ๆ เกี่ยวกับหัวข้อรหัส
นอกจาก โดยเฉพาะอย่างยิ่งเกี่ยวกับค่า ดูส่วน 18.2.1, 968 หน้าสำหรับรายละเอียด
หมายเหตุว่า กระทู้เดี่ยวควรเข้าถึงวัตถุที่มีอายุการใช้งานสิ้นสุด หมายความ
ปัญหาว่า เมื่อสิ้นสุดโปรแกรม คุณต้องให้แน่ใจว่า ไม่เข้าหัวข้อเดี่ยว
คง/โลกวัตถุ (ดูหัวข้อ 18.2.1 หน้า 967) .
, std::thread คลาสแสดงฟังก์ชันสมาชิกแบบคงที่เพื่อสอบถามคำแนะนำในสุด
จำนวนเธรดแบบขนาน:
รับรอง int () std::thread::hardware_concurrency
•ส่งกลับจำนวนของเธรดได้
•ค่านี้เป็นเพียงคำแนะนำ และไม่รับประกันให้แน่นอน.
•คืน 0 ถ้าหมายไม่ computable หรือที่กำหนดไว้.
www.it-ebooks.info
ยัง 18.3 เริ่มเธรด 981 รายละเอียด
18.3.7 Namespace this_thread
สำหรับเธรดใด ๆ รวมถึงหัวข้อหลัก ประกาศ namespace std::this_thread,
ซึ่งมีหัวข้อเฉพาะฟังก์ชันแสดงในตารางที่ 18.5.
ผลการดำเนินงาน
this_thread::get_id() ทำให้ ID ของบล็อก thread
this_thread::sleep_for(dur) ปัจจุบันเธรดสำหรับระยะเวลา dur
this_thread::sleep_until(tp) บล็อกเธรดจน timepoint tp
this_thread::yield() แนะนำเวลาไปหัวข้อถัดไป
18.5 ตาราง หัวข้อเฉพาะการดำเนินงานของ Namespace std::this_thread
หมายเหตุว่า sleep_for() และ sleep_until() มักจะแตกต่างกันเมื่อจัดการกับเวลาของระบบ
ปรับปรุง (ดูส่วน 5.7.5 หน้า 160 รายละเอียด) .
this_thread::yield() ดำเนินการไว้ให้คำแนะนำระบบที่ใช้
ให้ส่วนเหลือของเสี้ยวเวลาของเธรดปัจจุบันที่สภาพแวดล้อมรันไทม์สามารถ
กำหนดการให้หัวข้ออื่นทำ ทั่วไปอย่างหนึ่งคือการ ให้ตัวควบคุมเมื่อคุณรอ หรือ
"สำรวจ" สำหรับเธรดอื่น (ดูส่วน 18.1.1 หน้า 955) หรือสถานะอะตอมจะถูกกำหนด โดยเธรดอื่น
(เห็นส่วน 18.4.3 หน้า 986): 11
ขณะ (! readyFlag) { / / วนรอบจนกว่าข้อมูลจะพร้อม
std::this_thread::yield ();
}
เป็นอย่างอื่น เมื่อคุณไม่ได้รับล็อคหรือมี mutex ขณะล็อคล็อคหลาย mutexes ที่
ครั้ง, คุณสามารถทำโปรแกรมได้เร็วขึ้น โดยใช้ yield() ก่อนพยายาม ล็อค/mutexes ในการ
order.12
11 ต่าง ๆ ด้วย Bartosz Milewski สำหรับตัวอย่างนี้ได้
12 ด้วยโฮเวิร์ด Hinnant สำหรับตัวอย่างนี้ได้
www.it-ebooks.info
982 บท 18: เกิด
18.4 ตรงหัวข้อ หรือปัญหา
เกิด
ใช้เธรดหลายเกือบตลอดเวลาพร้อมกับการเข้าถึงข้อมูลพร้อมกันได้ ไม่ค่อยมีหลาย
กระทู้รันแยกกัน หัวข้ออาจมีข้อมูลที่ประมวลผล โดยเธรดอื่น หรือ
เตรียมเงื่อนไขเบื้องต้นที่จำเป็นเพื่อเริ่มต้นกระบวนการอื่น ๆ ได้
โดยมัลติเธรดกลายเป็นเรื่องยุ่งยากได้ หลายสิ่งที่สามารถไปผิด หรือ อีกทางหนึ่ง,
สิ่งสามารถทำงานแตกต่างจากสิ่งขำน่า (และแม้แต่ประสบการณ์) โปรแกรมเมอร์
อาจคาดหวังได้
ดังนั้น ก่อนสนทนาวิธีการซิงโครไนส์เธรดและการเข้าถึงข้อมูลพร้อมกัน เรามี
เข้าใจปัญหา แล้วเราสามารถสนทนาเทคนิคต่อไปนี้ให้ตรงหัวข้อ:
• Mutexes และ ล็อค (ดูส่วน 18.5 หน้า 989), รวมทั้ง call_once() (ดูส่วน 18.5.3,
page 1000)
•ตัวแปรเงื่อนไข (ดูส่วน 18.6 หน้า 1003)
• Atomics (ดูส่วน 18.7 หน้า 1012)
18.41 Beware ของเกิด!
ก่อนคุยรายละเอียดของปัญหาการเกิดพร้อมกัน ผมตั้งกฎในกรณีแรก
ต้องการเขียนโปรแกรมโดยไม่ต้องไปลึก subsection นี้ ถ้าคุณเรียนรู้กฎหนึ่ง
เกี่ยวกับจัดการกับกระทู้หลาย ควรมีต่อไปนี้:
แบบปลอดภัยเท่านั้นพร้อมเข้าถึงข้อมูลเดียวกัน โดยหลายหัวข้อโดย
ซิงโครไนส์เป็นเวลาทั้งหมดกระทู้อ่านเฉพาะข้อมูล
โดย "ข้อมูลเดียวกัน" ผมหมายถึง ข้อมูลที่ใช้ตำแหน่งหน่วยความจำเดียวกัน ถ้าแตกกระทู้พร้อม
เข้าถึงตัวแปรต่าง ๆ หรือวัตถุ หรือสมาชิกอื่นของพวกเขา ไม่มีปัญหาเนื่องจาก เนื่องจาก
C 11 รับประกันว่า จะมี location.13 หน่วยความจำของตัวเองแต่ละตัวแปรยกเว้นตัว bitfield เดียว
bitfields มีข้อยกเว้น เนื่องจาก bitfields ที่แตกต่างกันอาจใช้ตำแหน่งหน่วยความจำเพื่อให้เข้าถึง
bitfields อื่นหมายความ ถึงของเดียวข้อมูล
อย่างไรก็ตาม เมื่อเธรดที่สอง หรือมากกว่าพร้อมเข้าถึงตัวแปรเดียว หรือวัตถุ หรือสมาชิก
ของมัน และน้อยหนึ่งเธรดดำเนินการปรับเปลี่ยน คุณจะเอาเป็นเรื่องลึกถ้า
ไม่ซิงโครไนส์ที่เข้า อะไรคือการแข่งขันข้อมูลใน C ได้ ในมาตรฐาน C 11,
การแข่งขันข้อมูลถูกกำหนดเป็น "สองดำเนินการขัดแย้งกันในหัวข้อต่าง ๆ ที่หนึ่งไม่
อะตอม และไม่เกิดขึ้นก่อนอีก" การแข่งขันข้อมูลผลเสมอในลักษณะการทำงานไม่
เป็นเสมอ ด้วยสภาพการแข่งขัน ปัญหา ที่รหัสของคุณอาจจะทำสิ่งที่คุณตั้งใจ,
แต่จะไม่เสมอทำงาน ซึ่งเป็นปัญหาหมู่ nastiest ที่เราสามารถเผชิญในการเขียนโปรแกรมอย่างใดอย่างหนึ่ง เพียง
โดยใช้ข้อมูลอื่น ๆ จะเข้าโหมดผลิต หรือแพลตฟอร์มสลับอาจก็แบ่งของคุณ
รหัสได้ ดังนั้นจึงคงแนะนำให้ดูแลเกี่ยวกับการเข้าถึงข้อมูลพร้อมกันถ้าคุณใช้หลายเธรด
13 ที่ไม่ได้รับหนังสือค้ำประกันของตำแหน่งหน่วยความจำที่แยกต่างหากสำหรับวัตถุต่าง ๆ ก่อน C 11 C 98/C 03
มาตรฐานสำหรับเธรดเดียวเท่านั้น ดังนั้น พัฒน ก่อน C 11 พร้อมกันถึง
วัตถุต่าง ๆ ส่งผลให้เกิดพฤติกรรมไม่ แม้ว่าในทางปฏิบัติ มันมักจะเกิดปัญหาไม่
www.it-ebooks.info

การแปล กรุณารอสักครู่..

ผลลัพธ์ (ไทย) 2:[สำเนา]

คัดลอก!

18.3 เริ่มต้นในหัวข้อรายละเอียด 979
ผลงาน
packaged_task pt คอนสตรัคเริ่มต้น; สร้างงานชุดที่มี
ไม่มีรัฐที่ใช้ร่วมกันและไม่มีการจัดเก็บงาน
pt packaged_task (ฉ) สร้างวัตถุสำหรับงานฉ
packaged_task pt (alloc, f) การสร้างวัตถุ งานฉจัดสรรการใช้
alloc
packaged_task pt (RV) ย้ายคอนสตรัค; ย้าย RV บรรจุงาน
(งานและรัฐ) เพื่อ pt (RV ไม่มีรัฐที่ใช้ร่วมกัน
ในภายหลัง)
. pt ~ packaged_task () * ทำลายนี้ (อาจจะทำให้รัฐที่ใช้ร่วมกันพร้อม)
pt = มอบหมาย RV ย้าย; ย้ายกำหนดบรรจุ
RV งาน (งานและรัฐ) เพื่อ pt (RV ไม่มีที่ใช้ร่วมกัน
หลังจากนั้นรัฐ)
การแลกเปลี่ยน (pt1, pt2) สวอปบรรจุงาน
pt1.swap (pt2) สวอปงานบรรจุ
pt.valid () อัตราผลตอบแทน จริงถ้า pt มีสถานะที่ใช้ร่วมกัน
pt.get_future () ผลผลิตวัตถุในอนาคตเพื่อดึงรัฐที่ใช้ร่วมกัน
(ผลงาน)
pt (args) โทรงาน (ที่มีข้อโต้แย้งถ้ามี) และ
ที่ใช้ร่วมกันทำให้รัฐพร้อม
pt.make_ready_at_thread_exit (args ) โทรงาน (ที่มีข้อโต้แย้งถ้ามี) และที่
ด้ายออกทำให้สภาพพร้อมใช้ร่วมกัน
pt.reset () สร้างรัฐใหม่สำหรับการใช้งานร่วมกันจุด (อาจจะทำให้
รัฐที่ใช้ร่วมกันเก่าพร้อม)
ตารางที่ 18.3 การดำเนินงานของชั้น packaged_task <>
18.3.6 คลาส std :: ด้ายในรายละเอียด
วัตถุของมาตรฐานชั้น :: กระทู้แนะนำในมาตรา 18.2.1, หน้า 964, มีไว้เพื่อเริ่มต้นและ
เป็นตัวแทนของด้าย วัตถุเหล่านี้มีวัตถุประสงค์เพื่อแผนที่หนึ่งต่อหนึ่งกับหัวข้อที่ได้รับจาก
ระบบปฏิบัติการ ตารางที่ 18.4 รายการการดำเนินงานที่มีการเรียนด้าย
ความสัมพันธ์ระหว่างวัตถุด้ายและด้ายจะเริ่มต้นโดยการเริ่มต้น (หรือย้ายคัดลอก / กำหนด)
วัตถุ callable (ดูมาตรา 4.4, หน้า 54) ไปกับการขัดแย้งเพิ่มเติมตัวเลือก สมาคม
จบลงทั้งที่เข้าร่วม () (รอผลของด้าย) หรือถอดออก () (อย่างชัดเจนการสูญเสีย
ความสัมพันธ์ที่จะด้าย) หนึ่งหรืออื่น ๆ ที่จะต้องเรียกว่าก่อนที่ชีวิตของด้ายวัตถุ
ปลายหรือหัวข้อใหม่ได้รับการย้ายที่ได้รับมอบหมาย มิฉะนั้นโปรแกรมถูกยกเลิกด้วย std :: ยุติ ()
(ดูมาตรา 5.8.2, หน้า 162)
ถ้าวัตถุมีด้ายด้ายที่เกี่ยวข้องก็บอกว่าจะเป็น joinable ในกรณีที่ joinable ()
อัตราผลตอบแทนที่แท้จริงและ get_id () ผลตอบแทนถัวเฉลี่ย ID ด้ายที่แตกต่างจาก std :: ด้าย :: ID ()
รหัสกระทู้มีมาตรฐานประเภทของตัวเอง :: กระทู้ :: หมายเลข คอนสตรัคเริ่มต้นของผลตอบแทนถัวเฉลี่ยเป็นรหัสเฉพาะ
ที่เป็นตัวแทนของ "หัวข้อไม่." ด้าย :: get_id () ผลตอบแทนถัวเฉลี่ยค่านี้ถ้าหัวข้อไม่เกี่ยวข้องหรืออื่น
รหัสเฉพาะถ้าวัตถุด้ายมีความเกี่ยวข้องกับด้าย (เป็น joinable) การดำเนินงานได้รับการสนับสนุนเพียง
www.it-ebooks.info
980 บทที่ 18: Concurrency
ผลงาน
ด้ายทีคอนสตรัคเริ่มต้น; สร้างวัตถุ nonjoinable ด้าย
ด้ายที (ฉ, ... ) สร้างวัตถุด้ายเป็นตัวแทนของเอฟเริ่มเป็นด้าย (ที่มีการ
เพิ่มเติม args) หรือโยน std :: system_error
ด้าย T (RV) ย้ายคอนสตรัค; สร้างวัตถุหัวข้อใหม่ที่ได้รับสถานะของ
รถอาร์วีและทำให้รถอาร์วี nonjoinable
เสื้อ ~ ด้าย () * ทำลายนี้. เรียก std :: ยุติ ( ) ถ้าวัตถุที่เป็น joinable
t = มอบหมาย RV ย้าย; ย้ายกำหนดสถานะของรถอาร์วีไป t หรือโทร
std :: ยุติ () ถ้าเป็นเสื้อ joinable
t.joinable () ผลผลิตจริงถ้าเสื้อมีด้ายที่เกี่ยวข้อง (เป็น joinable)
เสื้อ . เข้าร่วม () รอด้ายที่เกี่ยวข้องให้เสร็จ (โยน std :: system_error
ถ้าด้ายไม่ joinable) และทำให้วัตถุ nonjoinable
t.detach () สมาคมประชาสัมพันธ์ของเสื้อที่จะด้ายในขณะที่ยังคงด้าย
(พ่นมาตรฐาน: : system_error ถ้าด้ายไม่ joinable) และทำให้
วัตถุ nonjoinable
t.get_id () ส่งคืนค่าที่ไม่ซ้ำกัน std :: ด้าย :: รหัสถ้า joinable หรือ
std :: ด้าย :: ID () ถ้าไม่
t.native_handle () ส่งกลับ แพลตฟอร์มเฉพาะประเภท native_handle_type เพื่อ
ขยาย nonportable
ตารางที่ 18.4 การดำเนินงานของวัตถุด้ายชั้น
ในรหัสกระทู้ที่จะเปรียบเทียบพวกเขาหรือจะเขียนให้กระแสออก นอกจากนี้ฟังก์ชันแฮช
ที่มีให้ในการจัดการรหัสด้ายในภาชนะบรรจุที่ไม่เรียงลำดับ (ดูมาตรา 7.9, หน้า 356) ID ด้าย
ของด้ายยกเลิกอาจนำกลับมาใช้อีกครั้ง อย่าทำให้สมมติฐานอื่น ๆ ที่เกี่ยวกับรหัสด้าย
นอกเหนือจากนั้นโดยเฉพาะอย่างยิ่งเกี่ยวกับค่าของพวกเขา ดูมาตรา 18.2.1, หน้า 968 สำหรับรายละเอียด
โปรดทราบว่าหัวข้อเดี่ยวไม่ควรเข้าถึงวัตถุที่มีชีวิตจะจบลง นี้หมายถึง
ปัญหาที่ว่าเมื่อสิ้นสุดโปรแกรมที่คุณต้องให้แน่ใจว่าหัวข้อเดี่ยวไม่สามารถเข้าถึง
/ วัตถุคงที่ทั่วโลก (ดูมาตรา 18.2.1, หน้า 967)
นอกจากนี้มาตรฐานระดับ :: ด้ายให้ฟังก์ชันสมาชิกคงที่ ค้นหาคำแนะนำที่เป็นไปได้สำหรับ
จำนวนของหัวข้อขนาน:
ลงนาม int std :: ด้าย :: hardware_concurrency ()
•ส่งกลับตัวเลขของหัวข้อที่เป็นไปได้
•ค่านี้เป็นเพียงคำแนะนำและไม่ได้รับประกันเป็นที่แน่นอน
•ผลตอบแทน 0 ถ้า จำนวนไม่ได้คำนวณหรือกำหนดไว้อย่างดี
www.it-ebooks.info
18.3 เริ่มต้นหัวข้อในรายละเอียด 981
this_thread 18.3.7 Namespace
สำหรับกระทู้ใด ๆ รวมทั้งหัวข้อหลักประกาศ namespace std :: this_thread,
ซึ่งมีฟังก์ชั่นระดับโลกด้ายเฉพาะที่ระบุไว้ในตารางที่ 18.5
ผลการดำเนินงาน
this_thread :: get_id () ผลผลิต ID ของเธรดปัจจุบัน
this_thread :: sleep_for (Dur) บล็อกด้ายสำหรับระยะเวลา Dur
this_thread: : sleep_until (tp) บล็อกด้ายจน timepoint tp
this_thread :: ผลผลิต () คำแนะนำในการจัดตารางการด้ายต่อไป
ตารางที่ 18.5 ปฏิบัติการหัวข้อเฉพาะของ Namespace std :: this_thread
หมายเหตุ sleep_for ที่ () และ sleep_until () มักจะแตกต่างกันเมื่อจัดการกับระบบเวลา
การปรับเปลี่ยน (ดูมาตรา 5.7.5, หน้า 160, สำหรับรายละเอียด)
การดำเนินการ this_thread :: ผลผลิต ( ) มีไว้เพื่อให้คำแนะนำกับระบบที่จะเป็นประโยชน์
ที่จะให้ขึ้นเวลาที่เหลือของชิ้นเธรดปัจจุบันเพื่อให้สภาพแวดล้อมรันไทม์สามารถ
หมายกำหนดการใหม่เพื่อให้หัวข้ออื่น ๆ ในการทำงาน ตัวอย่างหนึ่งที่โดยทั่วไปคือการให้ขึ้นการควบคุมเมื่อคุณรอหรือ
"การสำรวจ" สำหรับเธรดอื่น (ดูมาตรา 18.1.1 การซื้อ, หน้า 955) หรือธงอะตอมจะถูกกำหนดโดยหัวข้ออื่น
(ดูมาตรา 18.4.3, หน้า 986): 11
ในขณะที่ (! readyFlag) {/ / ห่วงจนข้อมูลพร้อมที่
std :: this_thread :: ผลผลิต ();
}
อีกตัวอย่างหนึ่งเมื่อคุณล้มเหลวที่จะได้รับการล็อค mutex หรือในขณะที่ล็อคล็อคหลาย / mutexes ที่
เวลาคุณสามารถ ทำให้โปรแกรมประยุกต์ได้เร็วขึ้นโดยใช้อัตราผลตอบแทน () ก่อนที่จะพยายามล็อค / mutexes ใน
ที่แตกต่างกัน order.12
11 ขอบคุณ Bartosz Milewski เช่นนี้
12 ขอบคุณฮาวเวิร์ด Hinnant นี้เช่น
www.it-ebooks.info
982 บทที่ 18 : Concurrency
18.4 อรกระทู้หรือปัญหาของ
Concurrency
ใช้หลายหัวข้อที่จะถูกรวมมักจะมีการเข้าถึงข้อมูลพร้อมกัน ไม่ค่อยจะมีหลาย
หัวข้อทำงานเป็นอิสระจากกัน กระทู้อาจให้ข้อมูลที่ประมวลผลโดยหัวข้ออื่น ๆ หรือ
จัดเตรียมปัจจัยพื้นฐานที่จำเป็นในการเริ่มต้นกระบวนการอื่น ๆ
ซึ่งเป็นที่ที่จะกลายเป็นเรื่องยุ่งยาก multithreading หลายสิ่งหลายอย่างที่สามารถไปผิด หรือวางวิธีอื่น
หลายสิ่งสามารถทำงานแตกต่างจากสิ่งที่ไร้เดียงสา (และแม้มีประสบการณ์) โปรแกรม
อาจคาดหวัง
ดังนั้นก่อนที่จะพูดถึงวิธีการที่แตกต่างกันเพื่อประสานหัวข้อและการเข้าถึงข้อมูลพร้อมกันนี้เรายังมี
การทำความเข้าใจปัญหา แล้วเราสามารถหารือเกี่ยวกับเทคนิคต่อไปนี้เพื่อประสานหัวข้อ:
• mutexes และล็อค (ดูมาตรา 18.5, หน้า 989) รวมทั้ง call_once () (ดูมาตรา 18.5.3,
หน้า 1000)
•ตัวแปรสภาพ (ดูมาตรา 18.6, หน้า 1003)
• อะตอม (ดูมาตรา 18.7, หน้า 1012)
18.4.1 ระวัง Concurrency!
ก่อนที่จะคุยในรายละเอียดของปัญหาของการทำงานพร้อมกันให้ฉันกำหนดกฎข้อแรกเพียงในกรณีที่
คุณต้องการเริ่มต้นการเขียนโปรแกรมโดยไม่ต้องไปลงไปในความลึกของหมวดนี้ หากคุณเรียนรู้กฎหนึ่ง
เกี่ยวกับการจัดการกับหลายหัวข้อที่ควรจะเป็นต่อไปนี้:
วิธีที่ปลอดภัยเท่านั้นที่จะเห็นพ้องกันในการเข้าถึงข้อมูลเดียวกันโดยหลายหัวข้อไม่
ตรงกันคือเมื่อหัวข้อทั้งหมดเพียงอ่านข้อมูล
โดย "ข้อมูลเดียวกัน" ผมหมายความว่าข้อมูล ที่ใช้หน่วยความจำตำแหน่งเดียวกัน ถ้าหัวข้อที่แตกต่างพร้อมกัน
เข้าถึงตัวแปรที่แตกต่างกันหรือวัตถุหรือสมาชิกที่แตกต่างกันของพวกเขาไม่มีปัญหาเพราะตั้งแต่
C + +11 แต่ละตัวแปรยกเว้น bitfield รับประกันได้ว่าจะมีหน่วยความจำของตัวเอง location.13 เพียง
ข้อยกเว้น bitfields เพราะที่แตกต่างกัน bitfields อาจแบ่งปันตำแหน่งของหน่วยความจำเพื่อให้การเข้าถึง
ที่แตกต่างกัน bitfields หมายถึงการเข้าถึงที่ใช้ร่วมกันของข้อมูลเดียวกัน
แต่เมื่อสองคนหรือมากกว่ากระทู้พร้อมใช้ตัวแปรเดียวกันหรือวัตถุหรือสมาชิก
ของมันและอย่างน้อยหนึ่งในหัวข้อการดำเนินการปรับเปลี่ยนที่คุณสามารถได้อย่างง่ายดาย ได้รับเป็นปัญหาลึกถ้า
คุณไม่ได้ประสานเข้าที่ นี่คือสิ่งที่เรียกว่าการแข่งขันข้อมูลใน C + + ใน C + +11 มาตรฐาน
การแข่งขันข้อมูลที่ถูกกำหนดให้เป็น "สองการกระทำที่ขัดแย้งกันในหัวข้อที่แตกต่างกันอย่างน้อยหนึ่งซึ่งไม่ได้เป็น
อะตอมและไม่เกิดขึ้นก่อนที่อื่น ๆ . "การแข่งขันข้อมูลผลเสมอในพฤติกรรมที่ไม่ได้กำหนด
เช่นเคย กับสภาพการแข่งขันปัญหาคือว่ารหัสของคุณมักจะอาจจะทำสิ่งที่คุณตั้งใจ
แต่จะไม่เคยทำงานซึ่งเป็นหนึ่งในปัญหา nastiest ที่เราสามารถเผชิญในการเขียนโปรแกรม เพียง
โดยใช้ข้อมูลอื่น ๆ ที่จะเข้าสู่โหมดการผลิตหรือการเปลี่ยนแพลตฟอร์มก็อาจจะทำลายของคุณ
รหัส ดังนั้นมันอาจจะเป็นความคิดที่ดีในการดูแลเกี่ยวกับการเข้าถึงข้อมูลพร้อมกันถ้าคุณใช้หลายหัวข้อ
13 การรับประกันการตั้งหน่วยความจำแยกต่างหากสำหรับวัตถุที่แตกต่างไม่ได้รับก่อนที่จะ C + +11 C + 98 / C + +03
เป็นมาตรฐานสำหรับการใช้งานเธรดเดียวเท่านั้น ดังนั้นการพูดอย่างเคร่งครัดก่อนที่จะ C + +11 เข้าถึงพร้อมกันไปยัง
วัตถุที่แตกต่างกันส่งผลให้เกิดพฤติกรรมที่ไม่ได้กำหนด แต่ในทางปฏิบัติมันมักจะเกิดปัญหาไม่
www.it-ebooks.info

การแปล กรุณารอสักครู่..

ผลลัพธ์ (ไทย) 3:[สำเนา]

คัดลอก!

1 เริ่มหัวข้อในรายละเอียดเนื้องานผล

packaged_task PT ปริยายคอนสตรัค ; สร้างแพคเกจงานกับรัฐ และไม่เก็บไว้
ไม่ใช้งาน
packaged_task PT ( F ) สร้างวัตถุสำหรับงาน f
packaged_task PT ( alloc , F ) สร้างวัตถุเพื่อใช้งาน f

การจัดสรร alloc packaged_task พ. ( RV ) ย้ายผู้รับเหมาก่อสร้าง ; ย้ายงานบรรจุ RV
( งานและรัฐ ) PT ( RV มีไม่ใช้สภาพ

หลังจากนั้น ) PT ~ packaged_task() ทำลาย * ( อาจทำให้สภาพพร้อมใช้งานรถบ้าน )
= งานเลื่อน เลื่อนกำหนดแพคเกจ
งาน RV ( งานและรัฐ ) PT ( รถบ้านไม่มีที่แบ่งปัน

หลังจากนั้นสลับ ( รัฐ ) PT1 , PT2 ) การบรรจุงาน
PT1 สลับ ( ชนิด ) การบรรจุงาน
PT valid() ผลตอบแทนจริงถ้า PT ได้แชร์สถานะ
pt .get_future() ผลผลิตวัตถุในอนาคตที่จะเรียกใช้รัฐ
( ผลของงาน )
PT ( ARGs ) สายงาน ( มีอาร์กิวเมนต์ตัวเลือก ) และทำให้สภาพพร้อมใช้

PT make_ready_at_thread_exit ( ARGs ) สายงาน ( มีอาร์กิวเมนต์ตัวเลือก ) และที่ใช้ร่วมกันออกทำให้ด้าย

สภาพพร้อมพ. . reset() สร้างใหม่ร่วมรัฐ PT ( อาจจะเก่าสภาพพร้อมใช้

โต๊ะ ) 1 .การดำเนินการของคลาส packaged_task < >
18.3.6 คลาส std : : หัวข้อในรายละเอียด
วัตถุของคลาส std : : กระทู้แนะนำ ในส่วน 18.2.1 หน้า 964 , ให้เริ่มต้นและ
แทนด้าย วัตถุเหล่านี้มีวัตถุประสงค์เพื่อแผนที่หนึ่งต่อหนึ่งกับหัวข้อโดย
ระบบปฏิบัติการ ตารางการใช้ห้องเรียน 18.4 รายการหัวข้อ
ความสัมพันธ์ระหว่างวัตถุด้ายและด้ายเริ่มต้นโดยการเริ่มต้น ( หรือคัดลอก / ย้าย กำหนดวัตถุ callable )
( ดูมาตรา 4.4 หน้า 54 ) กับตัวเลือกเพิ่มเติมอาร์กิวเมนต์ สมาคม
สิ้นสุดให้กับ join() ( รอผลของกระทู้ ) หรือ detach() ( อย่างชัดเจนเสีย
สมาคมจะด้าย )หนึ่งหรืออื่น ๆ ต้องโทรมาก่อนอายุการใช้งานของด้ายวัตถุ
สิ้นสุดหรือหัวข้อใหม่จะย้ายตาม มิฉะนั้นโปรแกรมการทำแท้งกับ std : : terminate()
( ดูมาตรา 5.8.2 , หน้า 162 ) .
ถ้าด้ายวัตถุมีความเกี่ยวข้อง ด้าย มันบอกว่าเป็น joinable . ในกรณีนี้ joinable()
ผลผลิตที่แท้จริง และ get_id() ผลผลิตหัวข้อ ID ที่แตกต่างจาก std : : หัวข้อ : :
id() .หัวข้อ : รหัสมีประเภทของตัวเอง : : หัวข้อ : : ID ตัวสร้างเริ่มต้นของผลผลิตเฉพาะ ID
แทน " หัวข้อ " กระทู้ : : get_id() ผลผลิตมูลค่านี้ถ้าไม่มีกระทู้ที่เกี่ยวข้องหรืออื่น
Unique ID ถ้าด้ายวัตถุที่เกี่ยวข้องกับกระทู้ ( joinable ) สนับสนุนการดำเนินงานเท่านั้น

www.it-ebooks ข้อมูล 980 บทที่ 18 : การดำเนินงานผลด้าย T

จัดสร้างเริ่มต้น ;สร้างวัตถุ nonjoinable ด้ายด้าย
T ( F , . . . ) สร้างด้ายวัตถุแทน F เริ่มเป็นหัวข้อ (
มีอาร์กิวเมนต์เพิ่มเติม ) หรือพ่น std : : system_error
ด้าย T ( RV ) ย้ายวัตถุก่อสร้าง สร้างหัวข้อใหม่ ซึ่งได้รับสถานะของ
RV RV , และทำให้ nonjoinable
T . ~ thread() ทำลาย * ; เรียก std : : terminate() ถ้าวัตถุ joinable
t = RV งานเลื่อนย้ายกำหนดสถานะของ RV หรือโทร T
T terminate() std : : ถ้าเป็น joinable
T . joinable() ผลตอบแทนจริงถ้าไม่มีเกี่ยวข้องหัวข้อ ( joinable )
. join() รอให้เกี่ยวข้องหัวข้อเสร็จ ( พ่น std : : system_error
ถ้าด้ายไม่ joinable ) และทำให้วัตถุ nonjoinable
ต. detach() ประชาสัมพันธ์สมาคม T กระทู้ในขณะที่หัวข้อต่อไป
( พ่น std : :system_error ถ้าด้ายไม่ joinable ) และทำให้

T . get_id() ส่งกลับวัตถุ nonjoinable STD เฉพาะ : : หัวข้อ : : ID ถ้า joinable หรือ
STD : : หัวข้อ : : id() ถ้าไม่ได้
T . native_handle() ส่งกลับเป็นแพลตฟอร์มสำหรับชนิดที่เฉพาะเจาะจง native_handle_type

โต๊ะ nonportable นามสกุล 18.4 . การดำเนินงานของวัตถุของคลาส Thread
สำหรับกระทู้ IDS เพื่อเปรียบเทียบ หรือเขียนไปยัง output ลำธาร นอกจากนี้ฟังก์ชัน hash
ให้จัดการด้ายรหัสในภาชนะเรียงลําดับ ( ดูมาตรา 9 , หน้า 356 ) หัวข้อรหัส
ของยกเลิกด้ายอาจจะซ้ำอีก ไม่ทำให้สมมติฐานเกี่ยวกับอื่น ๆด้ายรหัส
นอกจากที่โดยเฉพาะอย่างยิ่งเกี่ยวกับค่าของพวกเขา ดูส่วน 18.2.1 หน้า , 968 , รายละเอียด .
ทราบว่ากระทู้เดี่ยวไม่ควรเข้าถึงวัตถุที่มีชีวิตได้จบลงนี้หมายถึง
ปัญหานั้นได้ เมื่อสิ้นสุดโปรแกรม คุณต้องให้แน่ใจว่ากระทู้เดี่ยวไม่เข้า
ส่วนกลาง / สถิตวัตถุ ( ดูมาตรา 18.2.1 , หน้า 122 ) .
นอกจากนี้ รุ่น STD : : หัวข้อให้สมาชิกแบบคงที่ฟังก์ชันการค้นหาคําแนะนําสําหรับจํานวนที่สุด
หัวข้อ :
/ ขนาน หัวข้อ : : : : : int hardware_concurrency ( ) ส่งกลับจำนวน
-
หัวข้อที่เป็นไปได้- ค่าเป็นเพียงคำใบ้ และไม่รับประกันแน่นอน .
- กลับ 0 ถ้าตัวเลขไม่ได้คำนวณหรือกำหนดไว้อย่างดี

1 www.it-ebooks ข้อมูลเริ่มหัวข้อในรายละเอียด 981
18.3.7 namespace this_thread
สำหรับกระทู้ รวมถึงกระทู้หลัก < หัวข้อ > ประกาศ namespace std : : this_thread
, ซึ่งมีหัวข้อที่เฉพาะเจาะจงสำหรับฟังก์ชันแสดงในตารางการดำเนินงานผล

18 .this_thread : : get_id() ผลผลิต ID ของ this_thread ด้าย
ปัจจุบัน : : sleep_for ( เหล็ก ) บล็อกด้ายตลอดน่ะ
this_thread : : sleep_until ( TP ) บล็อกหัวข้อจนกว่า timepoint TP
this_thread : : yield() ใบ้เลื่อนนัดไปด้าย
โต๊ะ 18.5 . หัวข้อเฉพาะการดำเนินการของ namespace std : : this_thread
ทราบว่า sleep_for() sleep_until() และมักจะแตกต่างกัน เมื่อจัดการกับการปรับเวลา
ระบบ ( ดูที่ส่วน 5.7.5 , หน้า 160 , สำหรับรายละเอียด )
this_thread ผ่าตัด : : yield() มีให้เพื่อให้คําแนะนําระบบที่เป็นประโยชน์
ยอมแพ้ส่วนที่เหลือของชิ้นเวลาปัจจุบันด้ายแล้ว รันไทม์สิ่งแวดล้อมสามารถ
เลื่อนเพื่อให้กระทู้อื่น ๆที่จะใช้หนึ่งโดยทั่วไปตัวอย่างให้ขึ้นการควบคุมเมื่อคุณรอหรือ
" โพล " อีกกระทู้ ( ดูมาตรา 18.1.1 หน้า 955 ) หรืออะตอมเป็นธงที่จะถูกกำหนดโดยหัวข้ออื่น
( ดูมาตรา 18.4.3 หน้า 986 ) : 11
ในขณะที่ ! readyflag ) { / / ห่วงจนข้อมูลพร้อม
std : : this_thread : : yield() } ;

เป็นอีกตัวอย่าง เมื่อคุณล้มเหลวที่จะได้รับการล็อคหรือ mutex ในขณะที่ล็อคล็อค /
mutexes หลายครั้งคุณสามารถทำให้โปรแกรมเร็วขึ้น โดยใช้ yield() ก่อนพยายามล็อค / mutexes ใน

เพื่อที่แตกต่างกัน 12 11 ขอบคุณ bartosz milewski ตัวอย่างเช่นนี้ .
12 ขอบคุณโฮเวิร์ด hinnant ตัวอย่างเช่นนี้

www.it-ebooks ข้อมูลเอาไว้ บทที่ 18 : การ
ค่อนข้างตรงกันหัวข้อหรือปัญหา
พร้อมกัน
ใช้หลายกระทู้เป็นรวมเกือบเสมอกับการเข้าถึงข้อมูลพร้อมกันไม่ค่อยได้หลาย
กระทู้วิ่งอิสระของอีกคนหนึ่ง กระทู้อาจจะให้ข้อมูลหรือประมวลผล โดยหัวข้ออื่น ๆที่จำเป็นเพื่อเริ่มต้นกระบวนการเตรียม preconditions

นี่คือที่ ๆ ตอนหลังกลายเป็นยุ่งยาก มากสิ่งที่สามารถไปผิด หรือวางวิธีอื่น
หลายสิ่งสามารถทำตัวแตกต่างจากสิ่งที่ไร้เดียงสา ( และประสบการณ์ ) โปรแกรมเมอร์

ดังนั้นอาจคาดหวังก่อนที่จะพูดถึงวิธีการที่แตกต่างกันเพื่อให้กระทู้และการเข้าถึงข้อมูลพร้อมกัน เรามี
ที่จะเข้าใจปัญหา แล้วเราค่อยตามเทคนิคประสานกระทู้ :
- mutexes และล็อค ( ดูมาตรา 18 หน้า 989 ) ได้แก่ call_once() ( ดูมาตรา 18.5.3

, หน้า 1000 ) - เงื่อนไขตัวแปร ( ดูมาตรา 18.6 , หน้า 1002 )
- อะตอม ( ดูมาตรา 18.7 , หน้า 1 )
18.4 .1 ระวังพร้อมกัน !
ก่อนที่จะพูดถึงรายละเอียดของปัญหาการขอตั้งกฎแรกในกรณีที่คุณต้องการเริ่มโปรแกรม
โดยไม่ต้องไปในความลึกของส่วนนี้ . ถ้าคุณเรียนรู้กฎ
เกี่ยวกับการจัดการกับหลายๆ กระทู้ มันควรเป็นดังต่อไปนี้ :
เพียงวิธีที่ปลอดภัยเพื่อพร้อมเข้าถึงข้อมูลเดียวกันจากหลายๆ กระทู้ โดยไม่
กระทู้ทั้งหมดเพียงประสานเมื่ออ่านข้อมูล .
" ข้อมูล " เดียวกัน ผมหมายถึงข้อมูลที่ใช้ตำแหน่งหน่วยความจำเดียวกัน ถ้าต่างกันกระทู้พร้อมกัน
การเข้าถึงที่แตกต่างกันตัวแปรหรือวัตถุ หรือสมาชิกที่แตกต่างกันของพวกเขามีปัญหา เพราะ เนื่องจาก
c 11 ตัวแปรแต่ละตัว นอกจาก bitfield รับประกันว่าจะมี location.13 หน่วยความจำของตัวเอง ยกเว้นเพียง แต่เป็น bitfields
,เพราะ bitfields แตกต่างกันอาจแบ่งปันตำแหน่งหน่วยความจำเพื่อให้เข้าถึง
bitfields แตกต่างกันหมายความว่าใช้ร่วมกันเข้าถึงข้อมูลเดียวกัน
เมื่อสองคนหรือมากกว่ากระทู้พร้อมเข้าถึงตัวแปรเดียวกัน หรือวัตถุ หรือสมาชิก
แล้วอย่างน้อยหนึ่งหัวข้อ การปรับเปลี่ยน คุณสามารถได้รับในปัญหาลึกถ้า
คุณไม่ประสานที่เข้าถึงนี่คือสิ่งที่เรียกว่าข้อมูลการแข่งขันในค . ใน C 11 มาตรฐาน
แข่งข้อมูล หมายถึง “การกระทำที่ขัดแย้งกันสองในหัวข้อที่แตกต่างกันอย่างน้อยหนึ่งซึ่งไม่ใช่
อะตอม และไม่เกิดก่อนที่อื่น ๆ . " ข้อมูลการแข่งขันผลเสมอในพฤติกรรม undefined .
เช่นเคยด้วยเงื่อนไขการแข่งขัน ปัญหาคือว่า รหัสของคุณจะมักจะทำ สิ่งที่คุณตั้งใจ
แต่จะไม่เสมองานซึ่งเป็นหนึ่งในปัญหาที่เราเผชิญในที่สุด ตัวโปรแกรม แค่
โดยใช้ข้อมูลอื่น ๆ จะเข้าสู่โหมดการผลิต หรือการเปลี่ยนแพลตฟอร์มอาจจะทำลายรหัสของคุณ

ดังนั้นมันอาจจะเป็นความคิดที่ดีที่จะดูแลเกี่ยวกับข้อมูลการเข้าถึง ถ้าคุณใช้หลายกระทู้ .
13 รับประกันตำแหน่งของหน่วยความจำที่แยกต่างหากสำหรับวัตถุที่แตกต่างกันไม่ได้รับก่อน C 11 98 / c 03
cเป็นมาตรฐานเดียว threaded โปรแกรมเท่านั้น ดังนั้นการพูดอย่างเคร่งครัดก่อน C 11 พร้อมเข้าถึงวัตถุที่แตกต่างกันส่งผลให้พฤติกรรม
God แม้ว่าในการปฏิบัติมันมักจะไม่ก่อให้เกิดปัญหา
www.it-ebooks.info

การแปล กรุณารอสักครู่..

ภาษาอื่น ๆ

การสนับสนุนเครื่องมือแปลภาษา: กรีก, กันนาดา, กาลิเชียน, คลิงออน, คอร์สิกา, คาซัค, คาตาลัน, คินยารวันดา, คีร์กิซ, คุชราต, จอร์เจีย, จีน, จีนดั้งเดิม, ชวา, ชิเชวา, ซามัว, ซีบัวโน, ซุนดา, ซูลู, ญี่ปุ่น, ดัตช์, ตรวจหาภาษา, ตุรกี, ทมิฬ, ทาจิก, ทาทาร์, นอร์เวย์, บอสเนีย, บัลแกเรีย, บาสก์, ปัญจาป, ฝรั่งเศส, พาชตู, ฟริเชียน, ฟินแลนด์, ฟิลิปปินส์, ภาษาอินโดนีเซี, มองโกเลีย, มัลทีส, มาซีโดเนีย, มาราฐี, มาลากาซี, มาลายาลัม, มาเลย์, ม้ง, ยิดดิช, ยูเครน, รัสเซีย, ละติน, ลักเซมเบิร์ก, ลัตเวีย, ลาว, ลิทัวเนีย, สวาฮิลี, สวีเดน, สิงหล, สินธี, สเปน, สโลวัก, สโลวีเนีย, อังกฤษ, อัมฮาริก, อาร์เซอร์ไบจัน, อาร์เมเนีย, อาหรับ, อิกโบ, อิตาลี, อุยกูร์, อุสเบกิสถาน, อูรดู, ฮังการี, ฮัวซา, ฮาวาย, ฮินดี, ฮีบรู, เกลิกสกอต, เกาหลี, เขมร, เคิร์ด, เช็ก, เซอร์เบียน, เซโซโท, เดนมาร์ก, เตลูกู, เติร์กเมน, เนปาล, เบงกอล, เบลารุส, เปอร์เซีย, เมารี, เมียนมา (พม่า), เยอรมัน, เวลส์, เวียดนาม, เอสเปอแรนโต, เอสโทเนีย, เฮติครีโอล, แอฟริกา, แอลเบเนีย, โคซา, โครเอเชีย, โชนา, โซมาลี, โปรตุเกส, โปแลนด์, โยรูบา, โรมาเนีย, โอเดีย (โอริยา), ไทย, ไอซ์แลนด์, ไอร์แลนด์, การแปลภาษา.