18.3 Starting a Thread in DetailHav

18.3 Starting a Thread in Detail
Having introduced the high- and low-level interfaces to (possibly) start threads and deal with return
values or exceptions, let’s summarize the concepts and provide some details not mentioned yet.
call
std::async()
return values or exceptions automatically are
provided by a std::future
Starting
the Thread
Returning
Exceptions
create object of class
std::thread
set return values or exceptions in a
std::promise
and process it by a std::future
call task of class
std::packaged_task
return values or exceptions automatically are
provided by a std::future
Returning
Values
use a shared state
create object of class
std::thread
through type
std::exception_ptr
use shared variables
(synchronization required)
Figure 18.1. Layers of Thread Interfaces
Conceptionally, we have the following layers to start threads and deal with their return values or
exceptions (see Figure 18.1):
• With the low-level interface of class thread, we can start a thread. To return data, we need
shared variables (global or static or passed as argument). To return exceptions, we could use the
type std::exception_ptr, which is returned by std::current_exception() and can be
processed by std::rethrow_exception() (see Section 4.3.3, page 52).
• The concept of a shared state allows us to deal with return values or exceptions in a more convenient
way. With the low-level interface of a promise, we can create such a shared state, which
we can process by using a future.
• At a higher level, with class packaged_task or async(), the shared state is automatically
created and set with a return statement or an uncaught exception.
• With packaged_task, we can create an object with a shared state where we explicitly have to
program when to start the thread.
• With std::async(), we don’t have to care when the thread exactly gets started. The only thing
we know is that we have to call get() when we need the outcome.
Shared States
As you can see, a central concept used by almost all these features is a shared state. It allows the
objects that start and control a background functionality (a promise, a packaged task, or async()) to
www.it-ebooks.info
974 Chapter 18: Concurrency
communicate with the objects that process its outcome (a future or a shared future). Thus, a shared
state is able to hold the functionality to start, some state information, and its outcome (a return value
or an exception).
A shared state is ready when it holds the outcome of its functionality (when a value or an exception
is ready for retrieval). A shared state is usually implemented as a reference-counted object that
gets destroyed when the last object referring to it releases it.
18.3.1 async() in Detail
In general, as introduced in Section 18.1, page 946, std::async() is a convenience function to
start some functionality in its own thread if possible. As a result, you can parallelize functionality if
the underlying platform supports it but not lose any functionality if it doesn’t.
However, the exact behavior of async() is complex and highly depends on the launch policy,
which can be passed as the first optional argument. For this reason, each of the three standardized
forms of how async() can be called as described here from an application programmer’s point of
view:
future async (std::launch::async, F func, args...)
• Tries to start func with args as an asynchronous task (parallel thread).
• If this is not possible, it throws an exception of type std::system_error with the error code
std::errc::resource_unavailable_try_again (see Section 4.3.1, page 43).
• Unless the program aborts, the started thread is guaranteed to finish before the program ends.
• The thread will finish:
– If get() or wait() is called for the returned future
– If the last object that refers to the shared state represented by the returned future gets
destructed
• This implies that the call of async() will block until func has finished if the return value of
async() is not used.
future async (std::launch::deferred, F func, args...)
• Passes func with args as a “deferred” task, which gets synchronously called when wait() or
get() for the returned future gets called.
• If neither wait() nor get() is called, the task will never start.
future async (F func, args...)
• Is a combination of calling async() with launch policies std::launch:async and
std::launch::deferred. According to the current situation, one of the two forms gets chosen.
Thus, async() will defer the call of func if an immediate call in async launch policy is not
possible.
• Thus, if async() can start a new thread for func, it gets started. Otherwise, func is deferred until
get() or wait() gets called for the returned future.
www.it-ebooks.info
18.3 Starting a Thread in Detail 975
• The only guarantee this call gives is that after calling get() or wait() for the returned future,
func will have been called and finished.
• Without calling get() or wait() for the returned future, func might never get called.
• Note that this form of async() will not throw a system_error exception if it can’t call func
asynchronously (it might throw a system error for other reasons, though).
For all these forms of async(), func might be a callable object (function, member function, function
object, lambda; see Section 4.4, page 54). See Section 18.1.2, page 958, for some examples.
Passing a launch policy of std::launch::async|std::launch::deferred to async() results
in the same behavior as passing no launching policy. Passing 0 as launch policy results in
undefined behavior (this case is not covered by the C++ standard library, and different implementations
behave differently).
18.3.2 Futures in Detail
Class future,10 introduced in Section 18.1, page 946, represents the outcome of an operation. It
can be a return value or an exception but not both. The outcome is managed in a shared state, which
in general can be created by std::async(), a std::packaged_task, or a promise. The outcome
might not exist yet; thus, the future might also hold everything necessary to generate the outcome.
If the future was returned by async() (see Section 18.3.1, page 974) and the associated task was
deferred, get() or wait() will start it synchronously. Note that wait_for() and wait_until()
do not start a deferred task.
The outcome can be retrieved only once. For this reason, a future might have a valid or invalid
state: valid means that there is an associated operation for which the result or exception was not
retrieved yet.
Table 18.1 lists the operations available for class future.
Note that the return value of get() depends on the type future is specialized with:
• If it is void, get() also has type void and returns nothing.
• If the future is parametrized with a reference type, get() returns a reference to the return value.
• Otherwise, get() returns a copy or move assigns the return value, depending on whether the
return type supports move assignment semantics.
Note that you can call get() only once, because get() invalidates the future’s state.
For a future that has an invalid state, calling anything else but the destructor, the move assignment
operator, or valid() results in undefined behavior. For this case, the standard recommends
throwing an exception of type future_error (see Section 4.3.1, page 43) with the code
std::future_errc::no_state, but this is not required.
Note that neither a copy constructor nor a copy assignment operator is provided, ensuring that no
two objects can share the state of a background operation. You can move the state to another future
object only by calling the move constructor or the move assignment operator. However, the state
10 Originally, the class was named unique_future in the standardization process.
www.it-ebooks.info
976 Chapter 18: Concurrency
Operation Effect
future f Default constructor; creates a future with an invalid state
future f(rv) Move constructor; creates a new future, which gets the state
of rv, and invalidates the state of rv
f.~future() Destroys the state and destroys *this
f = rv Move assignment; destroys the old state of f, gets the state
of rv, and invalidates the state of rv
f.valid() Yields true if f has a valid state, so you can call the
following member functions
f.get() Blocks until the background operation is done (forcing a
deferred associated functionality to start synchronously),
yields the result (if any) or raises any exception that
occurred, and invalidates its state
f.wait() Blocks until the background operation is done (forcing a
deferred associated functionality to start synchronously)
f.wait_for(dur) Blocks for duration dur or until the background operation is
done (a deferred thread is not forced to start)
f.wait_until(tp) Blocks until timepoint tp or until the background operation
is done (a deferred thread is not forced to start)
f.share() Yields a shared_future with the current state and
invalidates the state of f
Table 18.1. Operations of Class future
of background tasks can be shared in multiple objects by using a shared_future object, which
share() yields.
If the destructor is called for a future that is the last owner of a shared state and the associated
task has started but not finished yet, the destructor blocks until the end of the task.
18.3.3 Shared Futures in Detail
Class shared_future (introduced in Section 18.1.3, page 960) provides the same semantics and
interface as class future (see Section 18.3.2, page 975) with the following differences:
• Multiple calls of get() are allowed. Thus, get() does not invalidate its state.
• Copy semantics (copy constructor, copy assignment operator) are supported.
• get() is a constant member function returning a const reference to the value stored in the
shared state (which means that you have to ensure that the lifetime of the returned reference is
shorter than the shared state). For class std::future, get() is a nonconstant member function
returning a move-assigned copy (or a copy if th

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

ยัง 18.3 เริ่มเธรดในรายละเอียด
มีนำระดับสูง และต่ำอินเตอร์เฟสที่ (อาจ) เริ่มต้นกระทู้ และเรื่องคืน
ค่าหรือข้อยกเว้น ลองสรุปแนวคิด และให้รายละเอียดบางอย่างที่ไม่ได้กล่าวถึงยัง
โทร
(std::async)
กลับค่าหรือข้อยกเว้นโดยอัตโนมัติมี
โดย std::future <>
เริ่มต้น
เธรด
Returning
ยกเว้น
สร้างออปเจ็กต์ของคลาส
std::thread
ตั้งค่าที่ส่งกลับข้อยกเว้นในการ
std::promise <>
และประมวลผล ด้วย std::future <>
เรียกงานของคลาส
std::packaged_task
กลับค่าหรือข้อยกเว้นโดยอัตโนมัติจะ
โดย std::future <>
Returning
ค่า
ใช้รัฐร่วม
สร้างออปเจ็กต์ของคลาส
std::thread
ผ่านชนิด
std::exception_ptr
ใช้ตัวแปรร่วม
(synchronization required)
รูป 18.1 ชั้นของหัวข้ออินเทอร์เฟซ
Conceptionally เรามีชั้นต่อไปนี้เพื่อเริ่มต้นกระทู้ และจัดการกับค่าที่ส่งคืน หรือ
(ดูรูปที่ 18.1) ข้อยกเว้น:
• ด้วยอินเตอร์เฟซที่ระดับล่างของชั้นด้าย เราสามารถเริ่มด้าย สอบ เราต้อง
(สากล หรือแบบคง หรือส่งผ่านเป็นอาร์กิวเมนต์) ตัวแปรที่ใช้ร่วมกัน การส่งกลับข้อยกเว้น เราสามารถใช้การ
ชนิด std::exception_ptr ซึ่งส่งกลับ โดยมาตรฐาน::current_exception() และสามารถ
ประมวลผล โดย std::rethrow_exception() (ดูหัวข้อ 4.3.3 หน้า 52) .
•แนวคิดของรัฐใช้ร่วมกันช่วยให้เราสามารถจัดการกับค่าที่ส่งกลับข้อยกเว้นในสะดวกกว่า
วิธีการ มีอินเทอร์เฟซที่ระดับต่ำของสัญญา เราสามารถสร้างดังกล่าวร่วมรัฐ ซึ่ง
เราสามารถประมวลผล โดยใช้ในอนาคตเป็นการ
•ในระดับที่สูงขึ้น มีคลาส packaged_task หรือ async() รัฐใช้ร่วมกันได้โดยอัตโนมัติ
สร้าง และตั้งค่า ด้วยคำสั่งส่งคืนสินค้าหรือการ uncaught ข้อยกเว้นการ
•กับ packaged_task เราสามารถสร้างวัตถุที่ มีสภาพใช้งานร่วมกันที่ชัดเจนมี
โปรแกรมจะเริ่มทำงานเธรดการ
•กับ std::async() เราไม่จำเป็นต้องดูแลเมื่อเธรดว่าจะเริ่มต้นได้ สิ่งเดียวที่
เรารู้คือ เราต้องโทร get() เมื่อเราต้องการผลลัพธ์
ร่วมอเมริกา
คุณสามารถดู แนวศูนย์กลางที่ใช้ โดยคุณลักษณะเหล่านี้เกือบทั้งหมดเป็นสิ่งที่ใช้ร่วมกัน จะช่วยให้การ
วัตถุที่เริ่มต้น และควบคุมการทำงานเบื้องหลัง (สัญญา บรรจุงาน หรือ async()) เพื่อ
www.it-ebooks.info
974 บท 18: เกิด
สื่อสารกับวัตถุที่ประมวลผล (ในอนาคตหรืออนาคตร่วม) ดังนั้น การใช้ร่วมกัน
รัฐจะสามารถระงับการทำงานเริ่มต้น ข้อมูลสถานะ และผล (ค่าคืน
หรือข้อยกเว้น) .
รัฐร่วมกันเป็นพร้อมเมื่อจะเก็บผลลัพธ์ของงาน (เมื่อค่าหรือข้อยกเว้น
พร้อมสำหรับเรียก) นำรัฐร่วมมักจะเป็นการอ้างอิงตรวจนับวัตถุที่
รับทำลายเมื่ออ้างอิงถึงวัตถุสุดท้ายออกมัน
ยัง 18.3async() 1 รายละเอียด
ทั่วไป ในส่วน 18.1 หน้า 946, std::async() เป็นฟังก์ชันเพื่อความสะดวก
เริ่มงานในเธรดของตัวเองไม่ ดังนั้น คุณสามารถ parallelize ฟังก์ชันถ้า
สนับสนุนแพลตฟอร์มแบบนั้น แต่ไม่สูญเสียฟังก์ชันการทำงานใด ๆ ถ้าไม่ได้
อย่างไรก็ตาม ลักษณะการทำงานแน่นอนของ async() มีความซับซ้อน และสูงขึ้นอยู่กับนโยบายเปิด,
ซึ่งสามารถส่งผ่านเป็นอาร์กิวเมนต์ตัวเลือกแรก ด้วยเหตุนี้ แต่ละของสามมาตรฐาน
รูปแบบวิธีการตามที่อธิบายไว้ที่นี่จากจุดของโปรแกรมเมอร์แอพลิเคชันที่สามารถเรียก async()
ดู:
ต่างเวลาในอนาคต (std::launch::async, F func อาร์กิวเมนต์...)
•พยายามเริ่ม func ด้วยอาร์กิวเมนต์เป็นการงานแบบอะซิงโครนัส (ด้ายขนาน) .
•ถ้าไม่ได้ มันพ่นข้อยกเว้นของชนิดมาตรฐาน::system_error รหัสข้อผิดพลาด
std::errc::resource_unavailable_try_again (ดูหัวข้อ 4.3.1 หน้า 43) .
•ยกเว้นโปรแกรม aborts ด้ายเริ่มมีรับประกันให้เสร็จสิ้นก่อนสิ้นสุดโปรแกรม
•เธรดจะเสร็จ:
– ถ้าเรียก get() หรือ wait() สำหรับอนาคตคืน
– ถ้าวัตถุสุดท้ายที่อ้างอิงถึงรัฐร่วมแสดง โดยอนาคตคืน
destructed
•หมายความว่า จะบล็อกเรียก async() จนกระทั่ง func เสร็จถ้าไม่ใช้ of
async() ค่าที่ส่งคืน
ต่างเวลาในอนาคต (std::launch:: เลื่อนเวลา F func อาร์กิวเมนต์...)
Func ผ่าน• มีอาร์กิวเมนต์เป็นงาน "ถูกเลื่อนออกไป" ซึ่งจะเรียกว่ากล่าวเมื่อได้รับการเรียกว่า or
get() wait() ในอนาคตส่งคืน .
•ถ้าไม่ wait() หรือ get() คือ งานจะไม่เริ่มการ
ต่างเวลาในอนาคต (F func อาร์กิวเมนต์...)
•เป็นชุดของโทร async() กับ std::launch:async เปิดตัวนโยบาย และ
std::launch:: เลื่อนเวลา ตามสถานการณ์ปัจจุบัน หนึ่งในสองรูปแบบได้รับการเลือกด้วย
ดัง async() จะตามเรียก func ถ้าไม่มีการเรียกทันทีในต่างเวลาเปิดนโยบาย
สุด
•ดังนี้ ถ้า async() สามารถเริ่มต้นหัวข้อใหม่สำหรับ func มันจะเริ่ม อย่างอื่น func จะเลื่อนเวลา until
get() หรือได้รับการเรียกว่า wait() สำหรับการส่งคืนในอนาคตได้
www.it-ebooks.info
ยัง 18.3 เริ่มเธรดใน 975 รายละเอียด
•รับประกันเรียกนี้ให้คือที่โทร get() หรือ wait() สำหรับอนาคต คืนเดียว
func จะถูกเรียก และเสร็จสิ้นการ
•ไม่โทร get() หรือ wait() สำหรับอนาคตคืน func อาจไม่ได้รับการเรียกได้
หมายเหตุ•ว่า async() แบบนี้จะไม่โยนการ system_error ข้อยกเว้นถ้ามันไม่สามารถเรียก func
แบบอะซิงโครนัส (มันอาจโยนความผิดพลาดของระบบด้วยเหตุผลอื่น ๆ แม้ว่า) .
สำหรับทั้งหมดเหล่านี้รูปแบบของ async(), func อาจเป็นวัตถุ callable (สมาชิกฟังก์ชัน ฟังก์ชัน ฟังก์ชัน
วัตถุ แลมบ์ดา ดูส่วน 4.4 หน้า 54) ได้ ดูหัวข้อ 18.1.2 หน้า 958 สำหรับตัวอย่างบาง.
ช่วยเปิดนโยบายมาตรฐาน::เปิด:: async|std::launch:: เลื่อนออกไปผล async()
ในลักษณะเดียวกันเป็นการผ่านนโยบายการเปิดใช้งานไม่ ช่วยเป็น 0 เปิดผลลัพธ์ของนโยบายใน
ยังไม่ได้กำหนดลักษณะการทำงาน (กรณีนี้ไม่ได้ครอบคลุม โดยไลบรารีมาตรฐาน C และการใช้งานที่แตกต่าง
ทำงานแตกต่างกัน) .
18.3.2 แผนล่วงหน้าในรายละเอียด
คลา<>ในอนาคต 10 ในหัวข้อ 18.1 หน้า 946 แสดงผลลัพธ์ของการดำเนินงาน มัน
ได้ค่าที่ส่งคืน หรือยกเว้น แต่ไม่ทั้งสองอย่าง ผลที่ได้ถูกจัดการในสถานะที่ใช้ร่วมกัน ซึ่ง
โดยทั่วไป สามารถถูกสร้าง โดย std::async(), std::packaged_task การ หรือสัญญา ผล
อาจมีอยู่ไม่ได้ ดังนั้น อนาคตอาจยังเก็บทุกอย่างที่จำเป็นเพื่อสร้างผลลัพธ์ได้
ถ้าอนาคตถูกส่งกลับ โดย async() (ดูหัวข้อ 18.3.1 หน้า 974) และงานเกี่ยวข้อง
เลื่อนเวลา get() หรือ wait() จะเริ่มพร้อมกัน หมายเหตุ()ที่ wait_for() และ wait_until
เริ่มต้นการเลื่อนเวลางานได้
ผลสามารถดึงเพียงครั้งเดียวได้ ด้วยเหตุนี้ ในอนาคตอาจถูกต้อง หรือไม่ถูกต้อง
สถานะ: ถูกต้องหมายความว่ามีการดำเนินการเกี่ยวข้องซึ่งผลการยกเว้นไม่
เรียกยังได้
18.1 ตารางแสดงรายการการดำเนินงานพร้อมใช้งานสำหรับคลาส<>ในอนาคตได้
หมายเหตุว่า ค่าที่ส่งคืนของ get() ขึ้นอยู่กับ<>ในอนาคตชนิดความด้วย:
•ถ้าเป็นโมฆะ get() นอกจากนี้ยังมีพิมพ์ยกเลิก และกลับไม่
•ถ้าอนาคต parametrized กับชนิดการอ้างอิง การอ้างอิงถึงการคืนค่าการคืนค่า get()
•จงระวัง get() ส่งกลับค่าการคัดลอก หรือย้ายกำหนดค่าที่ส่งคืน ขึ้นอยู่กับว่า
กลับสนับสนุนชนิดย้ายการกำหนดความหมาย.
หมายเหตุว่า คุณสามารถเรียก get() เพียงครั้งเดียว เพราะ get() invalidates สถานะของอนาคต
สำหรับอนาคตที่มีสถานะไม่ถูกต้อง เรียกสิ่งอื่นแต่ destructor กำหนดย้าย
ดำเนินการ หรือ valid() ผลลัพธ์ในการทำงานไม่ ในกรณีนี้ มาตรฐานแนะนำ
โยนข้อยกเว้นของชนิด future_error (ดูหัวข้อ 4.3.1 หน้า 43) กับรหัส
std::future_errc::no_state แต่ไม่จำเป็น.
หมายเหตุว่า ไม่มีตัวสร้างการคัดลอกหรือตัวดำเนินการกำหนดสำเนาไว้ มั่นใจว่าไม่
สองวัตถุสามารถใช้สถานะของการดำเนินงานเบื้องหลังได้ คุณสามารถย้ายรัฐเพื่ออนาคตอีก
วัตถุ โดยเรียกตัวสร้างย้ายหรือดำเนินการกำหนดย้ายเท่านั้น อย่างไรก็ตาม รัฐ
10 เดิม ชั้นชื่อว่า unique_future ในมาตรฐานกระบวนการ
www.it-ebooks.info
บท 976 18: เกิด
ผลการดำเนินงาน
f อนาคตเริ่มต้นตัวสร้าง สร้างอนาคตที่ มีสถานะไม่ถูกต้อง
f(rv) ในอนาคตย้ายตัวสร้าง สร้างใหม่ในอนาคต ซึ่งได้รับสถานะ
ของ rv และ invalidates รัฐ rv
f.~future() ทำลายรัฐ และทำลาย * นี้
f = rv ย้ายกำหนด ทำลายรัฐเก่าของ f ได้รับสถานะ
ของ rv และ invalidates รัฐ rv
f.valid() อัตราผลตอบแทนจริงถ้า f มีสถานะถูกต้อง เพื่อให้คุณสามารถเรียกการ
ต่อ functions
f.get() สมาชิกบล็อกจนกว่าทำการพื้นหลัง (บังคับเป็น
เลื่อนเวลาออกไปทำงานเชื่อมโยงเริ่มต้นกล่าว),
ก่อให้เกิดผล (ถ้ามี) หรือเพิ่มใด ๆ ยกเว้นที่
เกิดและ invalidates สถานะ
fwait() บล็อกจนกว่าทำการพื้นหลัง (บังคับการ
เลื่อนเวลาออกไปทำงานเชื่อมโยงเริ่มต้นบล็อก synchronously)
f.wait_for(dur) dur ระยะเวลา หรือจน กว่าจะดำเนินการพื้นหลัง
ทำ (เธรดถูกเลื่อนออกไปจะไม่บังคับให้บล็อก start)
f.wait_until(tp) จน timepoint tp หรือจน กว่าการพื้นหลัง
เสร็จ (เธรดถูกเลื่อนออกไปจะไม่บังคับให้เริ่มต้น)
fshare() ทำให้ shared_future กับสถานะปัจจุบัน และ
invalidates รัฐ f
18.1 ตาราง การดำเนินงานของ<>ในอนาคตชั้น
ของพื้นหลัง งานสามารถใช้ร่วมในวัตถุ โดยใช้การ shared_future วัตถุ อัตราผลตอบแทน which
share() ได้
ถ้า destructor จะถูกเรียกว่าสำหรับอนาคตที่เป็นเจ้าของรัฐใช้ร่วมกันและการเชื่อมโยงล่าสุด
งานได้เริ่มต้น แต่ยัง ไม่เสร็จ บล็อก destructor จนสิ้นสุดของงาน
18.3.3 ร่วมแผนล่วงหน้าในรายละเอียด
<>shared_future คลาส (แนะนำในส่วน 18.1.3 หน้า 960) มีความหมายเดียวกัน และ
อินเทอร์เฟซเป็นคลาสในอนาคต (ดูหัวข้อ 18.3.2 หน้า 975) มีความแตกต่างต่อไปนี้:
•เรียกหลายของ get() ได้รับอนุญาต ดังนั้น get() ไม่ทำให้สถานะของการ
•สำเนาความหมาย (ตัวสร้างสำเนา ตัวดำเนินการกำหนดสำเนา) ได้รับการสนับสนุน
• get() คือ ฟังก์ชันสมาชิกคงกลับการอ้างอิงค่าคงเป็นค่าที่เก็บไว้ใน
ร่วมรัฐ (ซึ่งหมายความว่าคุณต้องให้แน่ใจว่า อายุการใช้งานของการอ้างอิงที่ส่งกลับเป็น
สั้นกว่ารัฐร่วม) สำหรับคลา std::future, get() คือ ฟังก์ชันสมาชิก nonconstant
ความกำหนดย้ายสำเนา (สำเนาหรือถ้า th

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

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

STD โทร : : async()
กลับค่าหรือข้อยกเว้นโดยอัตโนมัติเป็น
โดย std : : ในอนาคต < >


เริ่มด้ายกลับมา

สร้างข้อยกเว้นวัตถุของคลาส : ด้าย

: :ตั้งคืนค่าหรือข้อยกเว้นใน std : : สัญญา
< >
และประมวลผลโดย std : : อนาคต < >
เรียกงานของชั้น

packaged_task std : : คืนค่าหรือข้อยกเว้นโดยอัตโนมัติเป็น
โดย std : : อนาคต < >


คืนค่าใช้ร่วมกัน
สร้างรัฐ วัตถุของคลาส
std : : ด้าย

ผ่านประเภท STD : : exception_ptr

( ต้องใช้ตัวแปรร่วมกันประสาน )
รูป 18.1 . ชั้นด้ายการเชื่อมต่อ
conceptionally เรามีชั้นต่อไปนี้เพื่อเริ่มหัวข้อ และจัดการกับค่าผลตอบแทนของพวกเขาหรือ
ข้อยกเว้น ( ดูรูป 18.1 ) :
- ด้วยอินเตอร์เฟซระดับชั้นด้าย เราสามารถเริ่มหัวข้อ เพื่อกลับข้อมูลที่เราต้องการ
แบ่งปันตัวแปร ( โลกหรือคงที่ หรือผ่านเป็นอาร์กิวเมนต์ ) กลับประเทศเราใช้
ประเภท std : : exception_ptr ซึ่งถูกส่งกลับโดย std : :current_exception() และสามารถประมวลผลโดย std : :
rethrow_exception() ( ดูส่วน 4.3.3 , หน้า 52 )
- แนวคิดของรัฐร่วมกัน ช่วยให้เราสามารถจัดการกับค่าตอบแทนหรือข้อยกเว้นในวิธีที่สะดวก
เพิ่มเติม กับอินเตอร์เฟซที่ระดับสัญญา เราสามารถสร้างเช่นรัฐร่วมกัน ซึ่งเราสามารถประมวลผลโดยใช้

บริการในอนาคต ในระดับที่สูงขึ้น กับการเรียน หรือ async() packaged_task ,ที่ใช้ร่วมกันโดยอัตโนมัติสร้างและตั้งค่าสถานะ
กับผลตอบแทนที่สั่ง หรือ ข้อยกเว้น uncaught .
- กับ packaged_task เราสามารถสร้างวัตถุที่มีสภาพที่ใช้ร่วมกันที่เราอย่างชัดเจนต้อง
โปรแกรมเมื่อเริ่มด้าย
- กับ std : : async() เราไม่ต้องไปดูแล เมื่อด้ายตรงได้รับ เริ่ม สิ่งเดียวที่
เรารู้คือเราต้องเรียก get()
เมื่อเราต้องการผลลัพธ์แบ่งปันสหรัฐอเมริกา
ที่คุณสามารถดู , กลางแนวคิดใช้โดยเกือบคุณสมบัติทั้งหมดเหล่านี้เป็นสถานะที่ใช้ร่วมกัน มันช่วยให้
วัตถุเริ่มและการควบคุมพื้นหลังการทำงาน ( สัญญา การบรรจุงาน หรือ async() )
www.it-ebooks ข้อมูล

อยู่บทที่ 18 : การติดต่อกับวัตถุที่กระบวนการผลของมัน ( อนาคตหรืออนาคตร่วมกัน ) ดังนั้น การแบ่งปัน
รัฐสามารถถือฟังก์ชันเริ่มต้น บางรัฐข้อมูล และผลของมัน ( คืนค่า

หรือข้อยกเว้น ) สภาพพร้อมใช้เมื่อมันถือผลการทํางาน ( เมื่อค่าหรือข้อยกเว้น
พร้อมดึง ) รัฐที่มักจะใช้เป็นอ้างอิงนับวัตถุ
จะถูกทำลายเมื่อวัตถุสุดท้ายหมายถึงมันออกมัน
7 .1 async() รายละเอียด
ทั่วไป ตามที่แนะนำในมาตรา 18.1 , หน้า 946 , std : : async() เป็นฟังก์ชั่นอำนวยความสะดวก

เริ่มต้นบางฟังก์ชันในหัวข้อของตัวเอง ถ้าเป็นไปได้ เป็นผลให้คุณสามารถ parallelize ฟังก์ชันถ้า
ภายใต้แพลตฟอร์มที่สนับสนุน แต่ไม่สูญเสียใด ๆ การทำงานถ้าไม่
แต่พฤติกรรมที่แน่นอนของ async() ซับซ้อนสูง ขึ้นอยู่กับการเปิดตัวนโยบาย
ซึ่งสามารถผ่านเป็นอาร์กิวเมนต์ตัวเลือกแรก ด้วยเหตุนี้ทั้งสามมาตรฐาน
รูปแบบวิธีการ async() สามารถเรียกตามที่อธิบายไว้ที่นี่ จากจุดโปรแกรมของโปรแกรมเมอร์ของมุมมอง :

อนาคตการ ( std : : เปิด : : การ F func ARGs , . . . )
- พยายามที่จะเริ่มต้นด้วยมีอาร์กิวเมนต์เป็น func ( ด้ายขนาน ) งานแบบอะซิงโครนัส .
- ถ้ามันเป็นไปไม่ได้ มันโยนข้อยกเว้น ประเภท STD : :system_error กับรหัสข้อผิดพลาด
std : : errc : : resource_unavailable_try_again ( ดูส่วนใน , หน้า 43 )
- ถ้าโปรแกรมถูกยกเลิก , เริ่มหัวข้อรับประกันให้เสร็จก่อนสิ้นสุดโครงการ .
- ด้ายจะเสร็จสิ้น :
) ถ้า get() หรือ wait() เรียกว่าให้กลับมา–อนาคต
ถ้า เมื่อวัตถุนั้นหมายถึงรัฐร่วมแสดงโดยกลับมา

destructed ได้รับในอนาคต- บางที่เรียก async() จะบล็อกจนเสร็จ ถ้าผลตอบแทน func ค่า

async() ไม่ได้ใช้ ในอนาคตการ ( std : : เปิด : : ยืดเวลา , F func ARGs , . . . )
- ผ่าน func กับมีอาร์กิวเมนต์เป็น " รอ " งานซึ่งได้รับ synchronously เรียกเมื่อ wait() หรือ
get() สำหรับกลับได้รับในอนาคต เรียกว่า ถ้าไม่ get()
- wait() หรือที่เรียกว่า งานจะเริ่ม
ในอนาคตการ ( func ARGs F ,
- . . . . . . . ) คือการรวมกันของการเรียก async() กับนโยบาย STD เปิดตัว : : เปิดตัว : การและ
STD : : เปิด : : เลื่อน . ตามสถานการณ์ปัจจุบัน หนึ่งใน 2 รูปแบบที่ถูกเลือก .
ดังนั้น async() จะยืดเวลาการเรียก func ถ้าเรียกทันทีในนโยบายการไม่เปิด
-
ที่สุด ดังนั้น ถ้า async() สามารถเริ่มหัวข้อใหม่สำหรับ func มันเริ่ม มิฉะนั้นจะรอจนกว่า
get() func หรือ wait() ถูกเรียกคืนในอนาคต www.it-ebooks

1 . ข้อมูลเริ่มหัวข้อในรายละเอียด 975
- เพียงการรับประกันนี้เรียกให้ หลังจากโทร get() หรือ wait() เพื่อกลับมาในอนาคต
func จะถูกเรียกและเสร็จสิ้น .
- โดยไม่ต้องโทร get() หรือ wait() สำหรับ กลับไปในอนาคต , func อาจไม่เคยรับโทร .
- หมายเหตุ แบบฟอร์มนี้ของ async() จะไม่โยน system_error ข้อยกเว้นถ้ามันไม่สามารถเรียก func
อะ ( มันอาจจะโยนข้อผิดพลาดของระบบสำหรับเหตุผลอื่น ๆ แม้ว่า )
ทั้งหมดเหล่านี้รูปแบบ async() func , อาจเป็นวัตถุคง ( ฟังก์ชันสมาชิกฟังก์ชัน ฟังก์ชัน
วัตถุ แลมด้า ดูมาตรา 4.4 หน้า 54 ) ดูส่วน 18.1.2 หน้า 958 สำหรับบางตัวอย่าง
ผ่านเปิดนโยบาย std : :เปิดตัว : : การ | std : : เปิด : : ทำตาม async() ผลลัพธ์
ในพฤติกรรมเดียวกันผ่านไม่เปิดตัวนโยบาย ผ่าน 0 เป็นดำเนินนโยบายที่ส่งผลพฤติกรรม Prayer ( กรณีนี้ไม่ครอบคลุมตามมาตรฐานห้องสมุดและใช้งานต่างกันแตกต่างกัน
)
18.3.2 ฟิวเจอร์สในรายละเอียด
เรียนในอนาคต < > 10 แนะนำในมาตรา 18.1 , หน้า 946 , แสดงให้เห็นถึงผลของการผ่าตัด มัน
สามารถคืนค่า หรือ ข้อยกเว้น แต่ไม่ทั้งสอง ผลการจัดการในสถานะที่ใช้ร่วมกัน ซึ่ง
โดยทั่วไปสามารถสร้างขึ้นโดย std : : async() , std : : packaged_task หรือสัญญา ผล
อาจไม่มีอยู่เลย ดังนั้น ในอนาคตอาจจะยังเก็บทุกอย่างที่จำเป็นในการสร้างผล .
ถ้าในอนาคตจะถูกส่งกลับโดย async() ( ดูมาตรา 18.3.1 หน้า 974 ) และที่เกี่ยวข้องงานเลื่อน
,get() หรือ wait() จะเริ่มต้น synchronously . ทราบว่า wait_for() และ wait_until()
ไม่เริ่มเลื่อนงาน .
ผลสามารถดึงเพียงครั้งเดียว ด้วยเหตุผลนี้ อนาคตอาจจะถูกต้องหรือสถานะไม่ถูกต้อง
: วิธีการที่ถูกต้องมีการดําเนินงานที่เกี่ยวข้องซึ่งผลหรือข้อยกเว้นไม่ได้

และ ดึงเลย ตารางรายการการดำเนินงานของห้องเรียนในอนาคต < > .
หมายเหตุที่คืนค่าของ get() ขึ้นอยู่กับชนิดในอนาคต < > เป็นผู้เชี่ยวชาญกับ :
- ถ้าเป็นโมฆะ get() ยังมีช่องว่างพิมพ์และส่งกลับไม่มีอะไร .
- ถ้าในอนาคตมี parametrized กับชนิดของการอ้างอิง get() ส่งกลับการอ้างอิงถึงกลับค่า .
- get() จะคัดลอกหรือมิฉะนั้น เลื่อนส่งค่าคืน ขึ้นอยู่กับว่าผลตอบแทนประเภทสนับสนุนย้ายงาน

อรรถศาสตร์ทราบว่าคุณสามารถเรียก get() ครั้งเดียวเท่านั้น เพราะการ get() ในอนาคตรัฐ
เพื่ออนาคต ซึ่งมีสถานะที่ไม่ถูกต้อง , เรียกสิ่งอื่น แต่เดสทรัคเตอร์ , ย้ายงาน
) หรือ valid() ผลลัพธ์ในพฤติกรรมไม่ได้กำหนด . สำหรับคดีนี้ มาตรฐานแนะนำ
โยนข้อยกเว้น ประเภท future_error ( ดูส่วนใน , หน้า 43 ) กับรหัส
std : : : : no_state future_errc ,แต่นี่ไม่ต้อง
ทราบว่าทั้งคัดลอกคอนสตรัคเตอร์หรือคัดลอกงานผู้ประกอบการให้บริการเพื่อให้มั่นใจว่าไม่มี
สองวัตถุสามารถแบ่งสภาพของพื้นหลังผ่าตัด คุณสามารถย้ายรัฐไปอีกในอนาคต
เพียงวัตถุโดยการเรียกคอนสตรักเตอร์ หรือการย้ายงาน ย้ายผู้ประกอบการ แต่รัฐ
10 ตอนแรกชั้นชื่อ unique_future ในกระบวนการมาตรฐาน .
www.it-ebooks ข้อมูล
1 บทที่ 18 : การดำเนินงานผลในอนาคต

F ตัวสร้างเริ่มต้น ; สร้างอนาคตกับอนาคต
ไม่ถูกต้อง F ( RV ) ย้าย ผู้สร้าง สร้างอนาคตใหม่ซึ่งได้รับสถานะ
ของ RV และการรัฐของ RV
F . ~ future() ทำลายรัฐและทำลาย *
F = RV งานเลื่อนทำลายสภาพเก่าของ F , ได้รับสถานะ
ของ RV และการรัฐของ RV
F . valid() ผลตอบแทนจริงถ้า F มีสถานะที่ถูกต้อง ดังนั้นคุณสามารถเรียกฟังก์ชัน f .

ต่อไปนี้สมาชิก get() บล็อกจนกว่าการผ่าตัดหลังเสร็จ ( บังคับให้รอการตัดบัญชีที่เกี่ยวข้องเพื่อเริ่ม synchronously ฟังก์ชัน

) ผลผลิตผล ( ถ้ามี ) หรือเพิ่มใด ๆยกเว้นว่า
เกิดขึ้นและการของรัฐ
Fwait() บล็อกจนกว่าการผ่าตัดหลังเสร็จ ( บังคับ
รอการตัดบัญชี ที่เกี่ยวข้องการทำงานเริ่มต้น synchronously )
f.wait_for ( เหล็ก ) บล็อกตลอดช่วง หรือจนกว่าการดำเนินงานพื้นฐาน
เสร็จ ( รอด้ายไม่ได้บังคับให้เริ่ม )
f.wait_until ( TP ) บล็อกจน timepoint TP หรือจนกว่าการผ่าตัด
เสร็จแล้ว ( พื้นหลัง เป็นรอด้ายไม่ได้บังคับให้เริ่ม )
Fshare() ผลผลิต shared_future กับ
สภาพปัจจุบันและการรัฐ F
ตารางที่ 18.1 . การดำเนินงานของคลาสในอนาคต < >
ของพื้นหลังของงานที่สามารถใช้ร่วมกันในหลายวัตถุโดยใช้ shared_future วัตถุ ซึ่งผลผลิต share()
.
ถ้าเดสทรัคเตอร์ เรียกว่า เพื่ออนาคต ซึ่งเป็นเจ้าของล่าสุดของรัฐร่วมกันและเชื่อมโยง
งานเริ่มแต่ไม่เสร็จยังส่วนเดสทรัคเตอร์บล็อกจนจบงาน 18.3.3 ร่วมกันในรายละเอียด

) เรียน shared_future < > ( แนะนำในส่วน 18.1.3 หน้า 960 ) ให้ความหมายเดียวกันและ
อินเตอร์เฟซที่คลาสในอนาคต ( ดูมาตรา 18.3.2 หน้า 975 ) กับความแตกต่างดังต่อไปนี้ :
- หลายสายของ get() ที่ได้รับอนุญาต ดังนั้น get() ไม่ได้สถานะเป็นโมฆะ
- สำเนาอรรถศาสตร์ ( คัดลอกคอนสตรัคคัดลอก ( งาน ) ได้รับการสนับสนุน .
- get() เป็นค่าคงที่ฟังก์ชันสมาชิกกลับ Const อ้างอิงค่าเก็บไว้ใน
ร่วมรัฐ ( ซึ่งหมายความว่าคุณต้องให้แน่ใจว่าการใช้งานของกลับอ้างอิง
สั้นกว่าร่วมรัฐ ) เรียน std : : อนาคต get() เป็น nonconstant ฟังก์ชันสมาชิก
กลับย้ายให้คัดลอก ( หรือสำเนา ถ้าครั้งที่