การคืนการควบคุมให้รันไทม์
หากยังจำได้จากหัวข้อ“โปรแกรม async โปรแกรมแรกของเรา” ณ จุด await แต่ละจุดนั้น Rust จะเปิดโอกาสให้รันไทม์ (runtime) พักการทำงานของทาสก์ (task) ไว้ชั่วคราว แล้วสลับไปทำงานอื่นแทนได้หากฟิวเจอร์ (future) ที่กำลังถูก await ยังไม่พร้อมทำงาน และในทางตรงกันข้ามก็เป็นจริงเช่นกัน: นั่นคือ Rust จะหยุดพักบล็อก async และส่งมอบการควบคุมกลับคืนให้แก่รันไทม์_เฉพาะ_ ณ จุด await เท่านั้น การทำงานทุกอย่างที่อยู่คั่นระหว่างจุด await จะดำเนินไปแบบซิงโครนัสเสมอ
นั่นหมายความว่า หากคุณเขียนการประมวลผลไว้เป็นจำนวนมากภายในบล็อก async โดยไม่มีจุด await เลยแม้แต่จุดเดียว ฟิวเจอร์นั้นจะบล็อกการทำงานจนฟิวเจอร์ตัวอื่นๆ ไม่สามารถคืบหน้าไปได้เลย บางครั้งคุณอาจได้ยินคำเรียกปรากฏการณ์นี้ว่า ฟิวเจอร์หนึ่ง_แย่งทรัพยากรจนฟิวเจอร์อื่นอดอยาก (starving)_ แม้ในบางกรณีสิ่งนี้อาจไม่ใช่เรื่องใหญ่นัก แต่หากคุณกำลังทำงานที่มีการเตรียมทรัพยากรหนักๆ หรืองานที่กินเวลายาวนาน หรือมีฟิวเจอร์ที่ต้องรันงานเฉพาะบางอย่างวนซ้ำไปเรื่อยๆ อย่างไม่มีที่สิ้นสุด คุณจำเป็นต้องพิจารณาอย่างรอบคอบว่าเมื่อใดและ ณ จุดใดที่ควรจะส่งมอบการควบคุมกลับคืนให้แก่รันไทม์
เรามาลองจำลองการทำงานที่ใช้เวลานานเพื่อเห็นภาพปัญหาการอดอยากนี้ให้ชัดเจน แล้วสำรวจดูวิธีแก้ไขกัน โดยในลิสติ้ง 17-14 เราจะสร้างฟังก์ชันชื่อ slow ขึ้นมา
extern crate trpl; // required for mdbook test
use std::{thread, time::Duration};
fn main() {
trpl::block_on(async {
// We will call `slow` here later
});
}
fn slow(name: &str, ms: u64) {
thread::sleep(Duration::from_millis(ms));
println!("'{name}' ran for {ms}ms");
}
โค้ดนี้ใช้ std::thread::sleep แทนที่จะเป็น trpl::sleep เพื่อให้การเรียก slow บล็อกเธรดปัจจุบันตามจำนวนมิลลิวินาทีที่กำหนด โดยเราสามารถใช้ slow เป็นตัวแทนของการทำงานในโลกความจริงที่ทั้งกินเวลานานและมีพฤติกรรมแบบบล็อกการทำงาน
ในลิสติ้ง 17-15 เราใช้ slow จำลองการทำงานที่ผูกติดกับซีพียู (CPU-bound) เช่นนี้ภายในฟิวเจอร์คู่หนึ่ง
extern crate trpl; // required for mdbook test
use std::{thread, time::Duration};
fn main() {
trpl::block_on(async {
let a = async {
println!("'a' started.");
slow("a", 30);
slow("a", 10);
slow("a", 20);
trpl::sleep(Duration::from_millis(50)).await;
println!("'a' finished.");
};
let b = async {
println!("'b' started.");
slow("b", 75);
slow("b", 10);
slow("b", 15);
slow("b", 350);
trpl::sleep(Duration::from_millis(50)).await;
println!("'b' finished.");
};
trpl::select(a, b).await;
});
}
fn slow(name: &str, ms: u64) {
thread::sleep(Duration::from_millis(ms));
println!("'{name}' ran for {ms}ms");
}
ฟิวเจอร์แต่ละตัวจะส่งมอบการควบคุมกลับคืนให้แก่รันไทม์ก็ต่อเมื่อทำงานที่ช้าเสร็จสิ้นลงไปทั้งชุด_แล้วเท่านั้น_ หากคุณรันโค้ดนี้ จะเห็นเอาต์พุตดังนี้:
'a' started.
'a' ran for 30ms
'a' ran for 10ms
'a' ran for 20ms
'b' started.
'b' ran for 75ms
'b' ran for 10ms
'b' ran for 15ms
'b' ran for 350ms
'a' finished.
เช่นเดียวกับในลิสติ้ง 17-5 ที่เราใช้ trpl::select รันประชันฟิวเจอร์เพื่อดึงข้อมูลจากสอง URL ตัว select ก็จะทำงานเสร็จสิ้นลงทันทีที่ a ทำงานเสร็จ ทว่ากลับไม่มีการสลับแทรกการทำงานระหว่างการเรียก slow ของฟิวเจอร์ทั้งสองตัวเลย ฟิวเจอร์ a กวาดทำงานของตนทั้งหมดไปจนกระทั่งถึงจุด await ของการเรียก trpl::sleep จากนั้นฟิวเจอร์ b ถึงจะได้เริ่มทำงานทั้งหมดของตนจนกระทั่งถึงจุด await ของ trpl::sleep ในฝั่งมัน และสุดท้ายฟิวเจอร์ a จึงทำงานเสร็จสมบูรณ์ เพื่อให้ฟิวเจอร์ทั้งสองสามารถสลับกันคืบหน้างานระหว่างที่ประมวลผลงานที่ช้าของตนได้ เราจำเป็นต้องมีจุด await เพื่อส่งมอบการควบคุมกลับคืนให้แก่รันไทม์ และนั่นหมายความว่าเราจำเป็นต้องมีสิ่งที่เราสามารถ await ได้!
เราเห็นการส่งมอบการควบคุมลักษณะนี้เกิดขึ้นแล้วในลิสติ้ง 17-15: หากเราลบ trpl::sleep ที่ส่วนท้ายของฟิวเจอร์ a ออก ฟิวเจอร์ a ก็จะทำงานเสร็จสิ้นลงโดยที่ฟิวเจอร์ b ไม่มีโอกาสได้รัน_เลยแม้แต่นิดเดียว_ เราลองมาใช้ฟังก์ชัน trpl::sleep เป็นจุดเริ่มต้นในการเปิดทางให้แต่ละงานสลับกันเดินหน้าดู ดังแสดงในลิสติ้ง 17-16
extern crate trpl; // required for mdbook test
use std::{thread, time::Duration};
fn main() {
trpl::block_on(async {
let one_ms = Duration::from_millis(1);
let a = async {
println!("'a' started.");
slow("a", 30);
trpl::sleep(one_ms).await;
slow("a", 10);
trpl::sleep(one_ms).await;
slow("a", 20);
trpl::sleep(one_ms).await;
println!("'a' finished.");
};
let b = async {
println!("'b' started.");
slow("b", 75);
trpl::sleep(one_ms).await;
slow("b", 10);
trpl::sleep(one_ms).await;
slow("b", 15);
trpl::sleep(one_ms).await;
slow("b", 350);
trpl::sleep(one_ms).await;
println!("'b' finished.");
};
trpl::select(a, b).await;
});
}
fn slow(name: &str, ms: u64) {
thread::sleep(Duration::from_millis(ms));
println!("'{name}' ran for {ms}ms");
}
เราได้เพิ่มการเรียก trpl::sleep พร้อมระบุจุด await คั่นระหว่างการเรียก slow แต่ละครั้ง ตอนนี้การทำงานของฟิวเจอร์ทั้งสองจะสลับแทรกเข้าหากันแล้ว:
'a' started.
'a' ran for 30ms
'b' started.
'b' ran for 75ms
'a' ran for 10ms
'b' ran for 10ms
'a' ran for 20ms
'b' ran for 15ms
'a' finished.
ฟิวเจอร์ a ยังคงทำงานไปครู่หนึ่งก่อนจะส่งมอบการควบคุมให้ b เพราะมันเรียก slow ก่อนที่จะมีการเรียก trpl::sleep ใดๆ แต่หลังจากนั้นฟิวเจอร์ทั้งสองจะสลับการทำงานไปมาทุกครั้งที่ตัวใดตัวหนึ่งเดินทางมาถึงจุด await ในกรณีนี้เราใส่คั่นไว้หลังการเรียก slow ทุกครั้ง แต่ในความเป็นจริง เราสามารถแบ่งย่อยงานด้วยรูปแบบใดก็ได้ที่สมเหตุสมผลที่สุดสำหรับเรา
ทว่าในความเป็นจริง เราไม่ได้ต้องการที่จะ_หยุดหลับ (sleep)_ จริงๆ แต่อย่างใด เพราะสิ่งที่เราต้องการคือการผลักดันงานให้คืบหน้าไปอย่างรวดเร็วที่สุดเท่าที่จะทำได้ เราเพียงแค่อยากส่งมอบการควบคุมกลับคืนให้แก่รันไทม์เท่านั้น ซึ่งเราสามารถทำสิ่งนี้ได้โดยตรงด้วยฟังก์ชัน trpl::yield_now ในลิสติ้ง 17-17 เราจึงแทนที่การเรียก trpl::sleep เหล่านั้นทั้งหมดด้วย trpl::yield_now
extern crate trpl; // required for mdbook test
use std::{thread, time::Duration};
fn main() {
trpl::block_on(async {
let a = async {
println!("'a' started.");
slow("a", 30);
trpl::yield_now().await;
slow("a", 10);
trpl::yield_now().await;
slow("a", 20);
trpl::yield_now().await;
println!("'a' finished.");
};
let b = async {
println!("'b' started.");
slow("b", 75);
trpl::yield_now().await;
slow("b", 10);
trpl::yield_now().await;
slow("b", 15);
trpl::yield_now().await;
slow("b", 350);
trpl::yield_now().await;
println!("'b' finished.");
};
trpl::select(a, b).await;
});
}
fn slow(name: &str, ms: u64) {
thread::sleep(Duration::from_millis(ms));
println!("'{name}' ran for {ms}ms");
}
โค้ดนี้ไม่เพียงแต่สื่อเจตนาที่แท้จริงได้ชัดเจนยิ่งขึ้นเท่านั้น แต่ยังทำงานได้เร็วกว่าการใช้ sleep อย่างมีนัยสำคัญอีกด้วย เนื่องจากตัวจับเวลาที่ sleep ใช้นั้นมักจะมีขีดจำกัดในเรื่องความละเอียดของเวลา ตัวอย่างเช่น ฟังก์ชัน sleep เวอร์ชันที่เราใช้นี้จะหยุดหลับอย่างน้อย 1 มิลลิวินาทีเสมอ แม้ว่าเราจะส่งค่า Duration เพียง 1 นาโนวินาทีเข้าไปก็ตาม และขอเน้นย้ำอีกครั้งว่า คอมพิวเตอร์ยุคปัจจุบันนั้น_เร็วมาก_: ในเวลาเพียง 1 มิลลิวินาที มันสามารถคำนวณและประมวลผลงานได้มหาศาล!
นั่นหมายความว่า async มีประโยชน์แม้กระทั่งกับงานประเภทประมวลผลหนัก (compute-bound) ขึ้นอยู่กับว่าโปรแกรมของคุณกำลังทำงานอื่นใดควบคู่ไปด้วยหรือไม่ เพราะมันเป็นเครื่องมือชั้นยอดในการจัดโครงสร้างความสัมพันธ์ระหว่างแต่ละส่วนของโปรแกรม (แม้จะมีต้นทุน overhead จากสเตตแมชชีนของ async แลกมาด้วยก็ตาม) นี่คือรูปแบบหนึ่งของ_การทำงานหลายงานแบบร่วมมือกัน (cooperative multitasking)_ ซึ่งฟิวเจอร์แต่ละตัวมีอำนาจตัดสินใจว่าเมื่อใดจะยอมส่งมอบการควบคุมผ่านจุด await และด้วยเหตุนี้ ฟิวเจอร์แต่ละตัวจึงมีความรับผิดชอบที่จะต้องไม่บล็อกการทำงานไว้นานจนเกินไปด้วย ในระบบปฏิบัติการสมองกลฝังตัว (embedded OS) บางระบบที่พัฒนาด้วย Rust นี่คือรูปแบบการทำงานหลายงาน_เพียงรูปแบบเดียว_ที่มีให้ใช้งาน!
แน่นอนว่าในโค้ดการใช้งานจริง คุณคงไม่ได้เขียนสลับการเรียกฟังก์ชันกับจุด await ในทุกๆ บรรทัดเช่นนี้ แม้ว่าการยอมสละการควบคุม (yielding control) ในลักษณะนี้จะมีต้นทุนค่อนข้างต่ำ แต่ก็ไม่ได้เกิดขึ้นฟรีๆ ในหลายกรณี การพยายามแบ่งย่อยงานที่ประมวลผลหนักๆ อาจทำให้การทำงานโดยรวมช้าลงอย่างเห็นได้ชัด ดังนั้นบางครั้งการยอมให้งานบล็อกเพียงครู่สั้นๆ อาจให้ประสิทธิภาพ_โดยรวม_ที่ดีกว่า จงคอยตรวจวัดประสิทธิภาพจริงของโค้ดอยู่เสมอเพื่อค้นหาว่าคอขวดที่แท้จริงอยู่ที่ใด แต่ไม่ว่าอย่างไร กลไกพื้นฐานนี้คือหัวใจสำคัญที่คุณควรตระหนักไว้ หากคุณ_เริ่มสังเกตเห็น_ว่างานจำนวนมากกำลังรันเรียงลำดับกันไป ทั้งๆ ที่คุณตั้งใจให้มันทำงานพร้อมกัน!
การสร้างนามธรรม async ของเราเอง
เรายังสามารถนำฟิวเจอร์มาประกอบเข้าด้วยกัน (compose) เพื่อสร้างแพตเทิร์นใหม่ๆ ได้อีกด้วย ตัวอย่างเช่น เราสามารถสร้างฟังก์ชัน timeout ขึ้นมาจากองค์ประกอบ async พื้นฐานที่เรามีอยู่แล้ว และเมื่อเสร็จสิ้น ฟังก์ชันนี้ก็จะกลายเป็นองค์ประกอบพื้นฐานชิ้นใหม่ที่เราสามารถนำไปต่อยอดสร้างแอ็บสแตรกชัน async อื่นๆ เพิ่มขึ้นไปได้อีก
ลิสติ้ง 17-18 แสดงให้เห็นว่าเราคาดหวังให้ timeout นี้ทำงานร่วมกับฟิวเจอร์ที่ทำงานช้าอย่างไร
extern crate trpl; // required for mdbook test
use std::time::Duration;
fn main() {
trpl::block_on(async {
let slow = async {
trpl::sleep(Duration::from_secs(5)).await;
"Finally finished"
};
match timeout(slow, Duration::from_secs(2)).await {
Ok(message) => println!("Succeeded with '{message}'"),
Err(duration) => {
println!("Failed after {} seconds", duration.as_secs())
}
}
});
}
เรามาลองลงมืออิมพลีเมนต์สิ่งนี้กัน! เริ่มต้นจากการวางแผน API ของ timeout:
- ฟังก์ชันนี้ต้องเป็นฟังก์ชัน async ในตัวเอง เพื่อให้เราสามารถ await มันได้
- พารามิเตอร์แรกควรเป็นฟิวเจอร์ที่ต้องการสั่งให้รัน โดยเราสามารถกำหนดให้เป็นเจเนอริก (generic) เพื่อให้ทำงานกับฟิวเจอร์ชนิดใดก็ได้
- พารามิเตอร์ที่สองคือระยะเวลาสูงสุดที่จะรอ ซึ่งหากเราใช้
Durationก็จะทำให้ส่งต่อให้แก่trpl::sleepได้อย่างง่ายดาย - ฟังก์ชันควรคืนค่าเป็น
Resultโดยหากฟิวเจอร์ทำงานสำเร็จResultจะเป็นOkพร้อมกับค่าที่ฟิวเจอร์สร้างขึ้น แต่หากหมดเวลาเสียก่อนResultจะเป็นErrพร้อมระยะเวลาที่ตัวไทม์เอาต์รอไป
ลิสติ้ง 17-19 แสดงการประกาศฟังก์ชันนี้
extern crate trpl; // required for mdbook test
use std::time::Duration;
fn main() {
trpl::block_on(async {
let slow = async {
trpl::sleep(Duration::from_secs(5)).await;
"Finally finished"
};
match timeout(slow, Duration::from_secs(2)).await {
Ok(message) => println!("Succeeded with '{message}'"),
Err(duration) => {
println!("Failed after {} seconds", duration.as_secs())
}
}
});
}
async fn timeout<F: Future>(
future_to_try: F,
max_time: Duration,
) -> Result<F::Output, Duration> {
// Here is where our implementation will go!
}
นั่นตอบโจทย์ในแง่ของชนิดข้อมูลครบถ้วนแล้ว คราวนี้มาพิจารณาถึง_พฤติกรรมการทำงาน_ที่เราต้องการ: เราต้องการนำฟิวเจอร์ที่ส่งเข้ามามารันแข่งกับระยะเวลาที่กำหนด เราสามารถใช้ trpl::sleep สร้างฟิวเจอร์ตัวจับเวลาขึ้นมาจากระยะเวลานั้น แล้วใช้ trpl::select รันตัวจับเวลาแข่งกับฟิวเจอร์ที่ผู้เรียกส่งเข้ามา
ในลิสติ้ง 17-20 เราอิมพลีเมนต์ timeout ด้วยการใช้ pattern matching กับผลลัพธ์ที่ได้จากการ await trpl::select
extern crate trpl; // required for mdbook test
use std::time::Duration;
use trpl::Either;
// --snip--
fn main() {
trpl::block_on(async {
let slow = async {
trpl::sleep(Duration::from_secs(5)).await;
"Finally finished"
};
match timeout(slow, Duration::from_secs(2)).await {
Ok(message) => println!("Succeeded with '{message}'"),
Err(duration) => {
println!("Failed after {} seconds", duration.as_secs())
}
}
});
}
async fn timeout<F: Future>(
future_to_try: F,
max_time: Duration,
) -> Result<F::Output, Duration> {
match trpl::select(future_to_try, trpl::sleep(max_time)).await {
Either::Left(output) => Ok(output),
Either::Right(_) => Err(max_time),
}
}
การอิมพลีเมนต์ของ trpl::select นั้นไม่ได้กระจายความยุติธรรมเท่ากัน: กล่าวคือ มันจะทำการโพลล์ (poll) อาร์กิวเมนต์ตามลำดับที่ส่งเข้ามาเสมอ (ในขณะที่การอิมพลีเมนต์ select แบบอื่นๆ อาจสุ่มเลือกว่าจะโพลล์อาร์กิวเมนต์ใดก่อน) ดังนั้น เราจึงส่ง future_to_try เข้าไปยัง select เป็นตัวแรก เพื่อให้มันมีโอกาสทำงานจนเสร็จแม้ว่า max_time จะสั้นมากก็ตาม หาก future_to_try ทำงานเสร็จก่อน select จะคืนค่า Left พร้อมข้อมูลเอาต์พุตจาก future_to_try แต่หาก timer เสร็จก่อน select จะคืนค่า Right พร้อมเอาต์พุต () ของตัวจับเวลา
หาก future_to_try ทำงานสำเร็จและเราได้รับ Left(output) เราจะคืนค่า Ok(output) แต่หากตัวจับเวลานับถอยหลังหมดลงก่อนและเราได้รับ Right(()) เราจะละเลยค่า () ด้วยเครื่องหมาย _ แล้วคืนค่า Err(max_time) ออกไปแทน
เพียงเท่านี้เราก็ได้ฟังก์ชัน timeout ที่ใช้งานได้จริง ซึ่งประกอบขึ้นจากตัวช่วย async สองตัว และหากเรารันโค้ด มันจะแสดงผลกรณีหมดเวลาดังนี้:
Failed after 2 seconds
และเนื่องจากฟิวเจอร์สามารถนำมาประกอบร่วมกับฟิวเจอร์อื่นๆ ได้ คุณจึงสามารถสร้างเครื่องมือที่ทรงพลังอย่างยิ่งขึ้นมาจากองค์ประกอบย่อยๆ แบบ async ตัวอย่างเช่น คุณสามารถใช้แนวทางนี้ผสานไทม์เอาต์เข้ากับระบบลองใหม่ (retries) แล้วนำไปประยุกต์ใช้กับการเรียกใช้งานเครือข่าย (ดังเช่นในลิสติ้ง 17-5) ได้
ในทางปฏิบัติ คุณมักจะเขียนโค้ดโดยใช้ async และ await เป็นหลัก และใช้งานฟังก์ชันอย่าง select ตลอดจนมาโครอย่าง join! ในลำดับรองลงมา เพื่อควบคุมจังหวะการประมวลผลของฟิวเจอร์ชั้นนอกสุด
จนถึงตอนนี้ เราได้เห็นหลากหลายวิธีในการทำงานกับฟิวเจอร์หลายๆ ตัวไปพร้อมกันแล้ว ในหัวข้อถัดไป เราจะมาดูกันว่าเราสามารถจัดการกับฟิวเจอร์ที่ทยอยมาอย่างต่อเนื่องตามลำดับเวลาด้วย_สตรีม (stream)_ ได้อย่างไร