ประกอบทุกอย่างเข้าด้วยกัน: ฟิวเจอร์ ทาสก์ และเธรด
ดังที่เราได้เห็นในบทที่ 16 เธรด (thread) เป็นแนวทางหนึ่งสำหรับการทำงานพร้อมกัน (concurrency) และเราก็ได้เห็นอีกแนวทางหนึ่งในบทนี้: นั่นคือการใช้ async ร่วมกับฟิวเจอร์ (future) และสตรีม (stream) หากคุณกำลังสงสัยว่าเมื่อใดควรเลือกวิธีหนึ่งแทนอีกวิธี คำตอบคือ: ขึ้นอยู่กับสถานการณ์! และในหลายๆ กรณี ทางเลือกไม่ได้เป็นเรื่องของเธรด_หรือ_ async แต่เป็นเรื่องของการใช้เธรด_และ_ async ร่วมกันต่างหาก
ระบบปฏิบัติการหลายตัวมีโมเดลการทำงานพร้อมกันแบบใช้เธรดมานานหลายทศวรรษแล้ว และด้วยเหตุนี้ภาษาโปรแกรมจำนวนมากจึงรองรับโมเดลเหล่านี้ อย่างไรก็ตาม โมเดลเหล่านี้ก็มีข้อแลกเปลี่ยน (trade-offs) อยู่เช่นกัน บนระบบปฏิบัติการหลายตัว เธรดแต่ละตัวใช้หน่วยความจำค่อนข้างมาก นอกจากนี้ เธรดยังเป็นทางเลือกได้เฉพาะเมื่อระบบปฏิบัติการและฮาร์ดแวร์ของคุณรองรับเท่านั้น ซึ่งต่างจากคอมพิวเตอร์เดสก์ท็อปและสมาร์ตโฟนทั่วไป เพราะระบบสมองกลฝังตัว (embedded system) บางระบบไม่มีระบบปฏิบัติการเลย ดังนั้นพวกมันจึงไม่มีเธรดให้ใช้งานด้วยเช่นกัน
โมเดลของ async นำเสนอข้อแลกเปลี่ยนที่แตกต่างออกไป—และส่งเสริมซึ่งกันและกันในที่สุด ในโมเดล async การทำงานพร้อมกันไม่จำเป็นต้องมีเธรดของตัวเองเป็นเอกเทศ แต่สามารถรันบนทาสก์ (task) ได้ เช่นเดียวกับตอนที่เราใช้ trpl::spawn_task เพื่อเริ่มการทำงานจากฟังก์ชันแบบซิงโครนัสในหัวข้อสตรีม ทาสก์นั้นคล้ายกับเธรด แต่แทนที่จะถูกจัดการโดยระบบปฏิบัติการ มันจะถูกจัดการโดยโค้ดในระดับไลบรารี นั่นคือรันไทม์ (runtime)
มีเหตุผลว่าทำไม API สำหรับการสร้างเธรดและการสร้างทาสก์จึงคล้ายคลึงกันมาก เธรดทำหน้าที่เป็นขอบเขตสำหรับชุดการทำงานแบบซิงโครนัส การทำงานพร้อมกันจะเกิดขึ้นได้_ระหว่าง_เธรด ส่วนทาสก์ทำหน้าที่เป็นขอบเขตสำหรับชุดการทำงานแบบ_อะซิงโครนัส_ (asynchronous) ซึ่งการทำงานพร้อมกันจะเกิดขึ้นได้ทั้ง_ระหว่าง_ทาสก์และ_ภายใน_ทาสก์เดียวกัน เพราะทาสก์สามารถสลับการทำงานระหว่างฟิวเจอร์ต่างๆ ภายในตัวมันได้ สุดท้ายนี้ ฟิวเจอร์คือหน่วยการทำงานพร้อมกันที่ย่อยที่สุดใน Rust และฟิวเจอร์แต่ละตัวอาจเป็นตัวแทนของต้นไม้โครงสร้างของฟิวเจอร์อื่นๆ ได้ รันไทม์—โดยเฉพาะเอ็กซีคิวเตอร์ (executor) ของมัน—จะเป็นตัวจัดการทาสก์ และทาสก์ก็จะเป็นตัวจัดการฟิวเจอร์ ในแง่นั้น ทาสก์จึงเปรียบเสมือนเธรดน้ำหนักเบา (lightweight thread) ที่ถูกจัดการโดยรันไทม์ พร้อมด้วยความสามารถเพิ่มเติมที่ได้จากการถูกจัดการโดยรันไทม์แทนที่จะเป็นระบบปฏิบัติการ
นี่ไม่ได้หมายความว่าทาสก์แบบ async จะดีกว่าเธรดเสมอไป (หรือในทางกลับกัน) การทำงานพร้อมกันด้วยเธรดในบางแง่มุมเป็นโมเดลการเขียนโปรแกรมที่เรียบง่ายกว่าการทำงานพร้อมกันด้วย async ซึ่งนั่นอาจเป็นได้ทั้งจุดแข็งหรือจุดอ่อน เธรดมีลักษณะแบบ “สั่งแล้วลืม” (fire and forget) อยู่บ้าง เพราะพวกมันไม่มีแนวคิดที่เทียบเท่ากับฟิวเจอร์โดยตรง ดังนั้นพวกมันจึงรันจนเสร็จสมบูรณ์ไปเลยโดยไม่ถูกขัดจังหวะ ยกเว้นโดยตัวระบบปฏิบัติการเอง
และปรากฏว่าเธรดกับทาสก์มักจะทำงานร่วมกันได้เป็นอย่างดี เพราะทาสก์สามารถ (อย่างน้อยก็ในบางรันไทม์) ถูกย้ายข้ามไปมาระหว่างเธรดได้ ที่จริงแล้ว เบื้องหลังรันไทม์ที่เราใช้งานอยู่—รวมถึงฟังก์ชัน spawn_blocking และ spawn_task—ทำงานแบบหลายเธรด (multithreaded) โดยค่าเริ่มต้น! รันไทม์จำนวนมากใช้วิธีการที่เรียกว่า การขโมยงาน (work stealing) เพื่อย้ายทาสก์ไปมาระหว่างเธรดได้อย่างโปร่งใส โดยประเมินจากการใช้งานเธรดในขณะนั้น เพื่อเพิ่มประสิทธิภาพโดยรวมของระบบ แนวทางดังกล่าวจำเป็นต้องใช้ทั้งเธรด_และ_ทาสก์ ซึ่งก็ย่อมต้องมีฟิวเจอร์ด้วย
เมื่อต้องพิจารณาว่าจะเลือกใช้วิธีใดในสถานการณ์ใด ลองพิจารณากฎเกณฑ์คร่าวๆ (rule of thumb) เหล่านี้:
- หากงานนั้น_สามารถแบ่งทำแบบขนานได้ดีมาก_ (เน้นใช้ CPU หรือ CPU-bound) เช่น การประมวลผลชุดข้อมูลขนาดใหญ่ที่แต่ละส่วนสามารถประมวลผลแยกจากกันได้อย่างอิสระ การใช้เธรดจะเป็นทางเลือกที่ดีกว่า
- หากงานนั้น_เน้นการทำงานพร้อมกันสูง_ (เน้น I/O หรือ I/O-bound) เช่น การจัดการข้อความจากแหล่งต่างๆ มากมายที่อาจทยอยเข้ามาในช่วงเวลาหรืออัตราความเร็วที่ไม่แน่นอน async จะเป็นทางเลือกที่ดีกว่า
และหากคุณต้องการทั้งการทำงานแบบขนาน (parallelism) และการทำงานพร้อมกัน (concurrency) คุณก็ไม่จำเป็นต้องเลือกอย่างใดอย่างหนึ่งระหว่างเธรดกับ async เลย คุณสามารถนำทั้งสองมาใช้ร่วมกันได้อย่างอิสระ โดยปล่อยให้แต่ละอย่างทำหน้าที่ในส่วนที่มันถนัดที่สุด ตัวอย่างเช่น ลิสติ้ง 17-25 แสดงตัวอย่างที่พบได้บ่อยของการผสมผสานทั้งสองรูปแบบนี้เข้าด้วยกันในโค้ด Rust สำหรับใช้งานจริง
extern crate trpl; // for mdbook test
use std::{thread, time::Duration};
fn main() {
let (tx, mut rx) = trpl::channel();
thread::spawn(move || {
for i in 1..11 {
tx.send(i).unwrap();
thread::sleep(Duration::from_secs(1));
}
});
trpl::block_on(async {
while let Some(message) = rx.recv().await {
println!("{message}");
}
});
}
เราเริ่มต้นด้วยการสร้างแชนเนลแบบ async จากนั้นสร้างเธรดที่รับความเป็นเจ้าของ (ownership) ของฝั่งผู้ส่งในแชนเนลโดยใช้คีย์เวิร์ด move ภายในเธรด เราส่งตัวเลข 1 ถึง 10 โดยมีการนอนหลับหนึ่งวินาทีคั่นระหว่างแต่ละตัวเลข สุดท้าย เราสั่งรันฟิวเจอร์ที่สร้างขึ้นด้วยบล็อก async ที่ส่งให้กับ trpl::block_on เช่นเดียวกับที่เราทำมาตลอดทั้งบท ในฟิวเจอร์นั้น เรา await ข้อความเหล่านั้น เช่นเดียวกับในตัวอย่างการส่งผ่านข้อความอื่นๆ ที่เราได้เห็นมา
เพื่อย้อนกลับไปยังสถานการณ์ที่เราเปิดประเด็นไว้ในตอนต้นบท ลองจินตนาการถึงการรันชุดทาสก์การเข้ารหัสวิดีโอ (video encoding) โดยใช้เธรดเฉพาะสำหรับการประมวลผล (เนื่องจากการเข้ารหัสวิดีโอเป็นงานที่เน้นใช้พลังการประมวลผลสูง) แต่แจ้งเตือนไปยัง UI ว่าการทำงานเหล่านั้นเสร็จสิ้นแล้วผ่านทางแชนเนลแบบ async มีตัวอย่างการผสมผสานเช่นนี้ในกรณีการใช้งานจริงนับไม่ถ้วน
สรุป
นี่ไม่ใช่ครั้งสุดท้ายที่คุณจะได้เห็นเรื่องการทำงานพร้อมกันในหนังสือเล่มนี้ โปรเจกต์ในบทที่ 21 จะนำแนวคิดเหล่านี้ไปประยุกต์ใช้ในสถานการณ์ที่สมจริงยิ่งขึ้นกว่าตัวอย่างง่ายๆ ที่เราพูดคุยกันในบทนี้ และจะเปรียบเทียบการแก้ปัญหาด้วยการใช้เธรดกับการใช้ทาสก์และฟิวเจอร์ให้เห็นภาพชัดเจนยิ่งขึ้น
ไม่ว่าคุณจะเลือกแนวทางใดในเหล่านี้ Rust ก็มอบเครื่องมือที่คุณต้องการเพื่อเขียนโค้ดที่ปลอดภัย รวดเร็ว และทำงานพร้อมกันได้อย่างมั่นใจ—ไม่ว่าจะสำหรับเว็บเซิร์ฟเวอร์ที่ต้องรองรับปริมาณงานสูง (high-throughput) หรือสำหรับระบบปฏิบัติการบนสมองกลฝังตัวก็ตาม
ในบทถัดไป เราจะพูดถึงแนวทางตามธรรมเนียมปฏิบัติ (idiomatic) ในการจำลองโมเดลปัญหาและจัดโครงสร้างของทางแก้ปัญหาเมื่อโปรแกรม Rust ของคุณมีขนาดใหญ่ขึ้น นอกจากนี้ เราจะร่วมพูดคุยกันว่าแนวคิดของ Rust เชื่อมโยงอย่างไรกับสิ่งที่คุณอาจคุ้นเคยจากการเขียนโปรแกรมเชิงวัตถุ (object-oriented programming)