ฟิวเจอร์และวากยสัมพันธ์ async
หัวใจสำคัญของการเขียนโปรแกรมแบบอะซิงโครนัสใน Rust คือ_ฟิวเจอร์ (futures)_ ตลอดจนคีย์เวิร์ด async และ await ของภาษา
ฟิวเจอร์ (future) คือค่าที่อาจจะยังไม่พร้อมใช้งานในตอนนี้ แต่จะพร้อมใช้งาน ณ จุดใดจุดหนึ่งในอนาคต (แนวคิดนี้ปรากฏในภาษาโปรแกรมหลายภาษา แต่อาจใช้ชื่ออื่น เช่น task หรือ promise) โดยภาษา Rust ได้จัดเตรียมเทรต Future ไว้เป็นรากฐาน เพื่อให้การทำงานแบบอะซิงโครนัสรูปแบบต่างๆ สามารถอิมพลีเมนต์ด้วยโครงสร้างข้อมูลที่แตกต่างกันได้ แต่ยังคงมีอินเทอร์เฟซมาตรฐานร่วมกัน ใน Rust ชนิดข้อมูลใดที่อิมพลีเมนต์เทรต Future จะถือว่าเป็นฟิวเจอร์ โดยแต่ละฟิวเจอร์จะเก็บข้อมูลความคืบหน้าของตนเองเอาไว้ ตลอดจนระบุว่าสถานะ “พร้อมใช้งาน” ของมันหมายถึงอะไร
คุณสามารถระบุคีย์เวิร์ด async ให้กับบล็อกหรือฟังก์ชัน เพื่อกำหนดว่าพวกมันสามารถหยุดพักการทำงานชั่วคราวและกลับมาทำต่อได้ และภายในบล็อกหรือฟังก์ชัน async คุณสามารถใช้คีย์เวิร์ด await เพื่อ await ฟิวเจอร์ (นั่นคือรอให้ฟิวเจอร์นั้นพร้อมใช้งาน) ทุกจุดที่คุณเรียก await ฟิวเจอร์ภายในบล็อกหรือฟังก์ชัน async ถือเป็นจุดที่บล็อกหรือฟังก์ชันดังกล่าวอาจหยุดพักและกลับมาทำต่อในภายหลัง กระบวนการตรวจสอบกับฟิวเจอร์ว่าค่าผลลัพธ์พร้อมใช้งานแล้วหรือยังนั้นเรียกว่า การโพลล์ (polling)
ภาษาโปรแกรมอื่นๆ เช่น C# และ JavaScript ก็ใช้คีย์เวิร์ด async และ await สำหรับการเขียนโปรแกรมแบบ async เช่นเดียวกัน หากคุณคุ้นเคยกับภาษาเหล่านั้น คุณอาจสังเกตเห็นความแตกต่างอย่างมีนัยสำคัญในวิธีที่ Rust ออกแบบไวยากรณ์นี้ ซึ่งมีเหตุผลรองรับที่ดีอยู่เบื้องหลัง ดังที่เราจะได้เห็นกันต่อไป!
ในการเขียนโค้ด async ใน Rust เราจะใช้คีย์เวิร์ด async และ await เป็นหลัก ซึ่งคอมไพเลอร์ของ Rust จะแปลงพวกมันไปเป็นโค้ดที่เทียบเท่ากันโดยใช้เทรต Future คล้ายกับการแปลงลูป for ไปเป็นโค้ดที่เรียกใช้เทรต Iterator และเนื่องจาก Rust จัดเตรียมเทรต Future ไว้ให้ คุณจึงสามารถนำเทรตนี้ไปอิมพลีเมนต์ให้กับชนิดข้อมูลของคุณเองได้เมื่อจำเป็น ฟังก์ชันหลายตัวที่เราจะได้เห็นตลอดทั้งบทนี้จะคืนค่าชนิดข้อมูลที่มีการอิมพลีเมนต์ Future อยู่ในตัว เราจะย้อนกลับมาดูนิยามของเทรตนี้อย่างละเอียดอีกครั้งในตอนท้ายของบท แต่สำหรับตอนนี้ รายละเอียดเท่านี้ก็เพียงพอที่จะให้เราเริ่มต้นก้าวต่อไปได้แล้ว
ทั้งหมดนี้อาจจะฟังดูเป็นนามธรรมไปสักหน่อย เราจึงมาลองลงมือเขียนโปรแกรม async ตัวแรกกันเลย นั่นคือเว็บสแครปเปอร์ (web scraper) ขนาดเล็ก โดยเราจะส่ง URL เข้าไปสองรายการผ่านทางบรรทัดคำสั่ง แล้วให้โปรแกรมดึงข้อมูลของทั้งสองเว็บเพจมาพร้อมๆ กัน จากนั้นคืนผลลัพธ์ของหน้าเพจที่ประมวลผลเสร็จก่อน ตัวอย่างนี้จะมีไวยากรณ์ใหม่ๆ พอสมควร แต่ไม่ต้องกังวล เราจะอธิบายทุกสิ่งที่คุณจำเป็นต้องรู้ไปทีละขั้นตอน
โปรแกรม async โปรแกรมแรกของเรา
เพื่อให้บทนี้มุ่งเน้นไปที่การเรียนรู้กลไกของ async เป็นหลักโดยไม่ต้องกังวลกับการหยิบจับเครื่องมือชิ้นต่างๆ ในระบบนิเวศ เราจึงสร้างเครต trpl ขึ้นมา (trpl ย่อมาจาก “The Rust Programming Language”) เครตนี้จะทำการรีเอ็กซ์พอร์ต (re-export) ชนิดข้อมูล เทรต และฟังก์ชันที่จำเป็นทั้งหมดที่คุณต้องใช้ ซึ่งส่วนใหญ่มาจากเครต futures และ tokio ทั้งนี้ เครต futures เป็นแหล่งรวมการทดลองอย่างเป็นทางการสำหรับโค้ด async ของ Rust และเป็นที่ที่เทรต Future ถูกออกแบบขึ้นในตอนแรก ส่วน Tokio คือรันไทม์ async ที่ได้รับความนิยมและถูกใช้งานแพร่หลายที่สุดในโลกของ Rust ยุคปัจจุบัน โดยเฉพาะอย่างยิ่งสำหรับเว็บแอปพลิเคชัน แน่นอนว่ายังมีรันไทม์ชั้นยอดตัวอื่นๆ อีกมากมาย ซึ่งอาจจะเหมาะสมกับความต้องการเฉพาะทางของคุณมากกว่า แต่เราเลือกใช้เครต tokio อยู่เบื้องหลังของ trpl เพราะมันผ่านการทดสอบมาอย่างเข้มข้นและมีการใช้งานอย่างแพร่หลาย
ในบางกรณี trpl ยังเปลี่ยนชื่อหรือห่อหุ้ม API ดั้งเดิมเอาไว้ เพื่อให้คุณโฟกัสกับรายละเอียดที่เกี่ยวข้องกับบทนี้ได้โดยตรง หากคุณต้องการทำความเข้าใจว่าเครตนี้ทำอะไรบ้าง เราขอแนะนำให้เข้าไปดูซอร์สโค้ดของเครตนี้ คุณจะเห็นได้ชัดเจนว่าแต่ละสิ่งที่ถูกนำมาส่งออกซ้ำนั้นมาจากเครตใด และเราได้ใส่คำอธิบายประกอบ (comment) ไว้อย่างละเอียด
สร้างโปรเจกต์ไบนารีใหม่ชื่อ hello-async และเพิ่มเครต trpl เป็นดีเพนเดนซี:
$ cargo new hello-async
$ cd hello-async
$ cargo add trpl
ตอนนี้เราสามารถนำเครื่องมือต่างๆ ที่ trpl จัดเตรียมไว้มาใช้เขียนโปรแกรม async ตัวแรกได้แล้ว โดยเราจะสร้างเครื่องมือบรรทัดคำสั่งขนาดเล็กที่ดึงข้อมูลเว็บเพจสองหน้า สกัดเอาเอลิเมนต์ <title> จากแต่ละหน้าออกมา แล้วพิมพ์ชื่อเรื่องของหน้าเพจที่เสร็จสิ้นกระบวนการทั้งหมดเป็นอันดับแรก
การนิยามฟังก์ชัน page_title
เรามาเริ่มจากการเขียนฟังก์ชันที่รับ URL ของหน้าเพจหนึ่งหน้าเป็นพารามิเตอร์ ทำการส่งคำขอไปยัง URL ดังกล่าว แล้วคืนข้อความในเอลิเมนต์ <title> ออกมา (ดูในลิสติ้ง 17-1)
extern crate trpl; // required for mdbook test
fn main() {
// TODO: we'll add this next!
}
use trpl::Html;
async fn page_title(url: &str) -> Option<String> {
let response = trpl::get(url).await;
let response_text = response.text().await;
Html::parse(&response_text)
.select_first("title")
.map(|title| title.inner_html())
}
ขั้นแรก เรานิยามฟังก์ชันชื่อ page_title และกำกับด้วยคีย์เวิร์ด async จากนั้นเราใช้ฟังก์ชัน trpl::get เพื่อดึงข้อมูลจาก URL ที่ส่งเข้ามา แล้วใส่คีย์เวิร์ด await เพื่อรอรับการตอบกลับ (response) และในการดึงข้อความของ response เราเรียกเมธอด text ของมันแล้วรออีกครั้งด้วยคีย์เวิร์ด await ซึ่งทั้งสองขั้นตอนนี้เป็นการทำงานแบบอะซิงโครนัส สำหรับฟังก์ชัน get นั้นเราต้องรอให้เซิร์ฟเวอร์ส่งส่วนแรกของการตอบกลับมา ซึ่งรวมถึง HTTP header, คุกกี้ ฯลฯ ที่อาจถูกส่งแยกจากบอดี้ (body) ของการตอบกลับ และโดยเฉพาะอย่างยิ่งหากบอดี้มีขนาดใหญ่ ก็อาจต้องใช้เวลากว่าข้อมูลทั้งหมดจะมาถึง และเนื่องจากเราต้องรอให้ข้อมูลการตอบกลับมาถึง_ทั้งหมด_ เมธอด text จึงต้องเป็นแบบ async ด้วยเช่นกัน
เราจำเป็นต้องเรียก await ฟิวเจอร์ทั้งสองตัวนี้อย่างชัดแจ้ง เพราะฟิวเจอร์ในภาษา Rust มีคุณสมบัติแบบ_เลซี่ (lazy)_: พวกมันจะไม่เริ่มทำอะไรเลยจนกว่าคุณจะสั่งให้ทำด้วยคีย์เวิร์ด await (ในความเป็นจริง Rust จะแสดงคำเตือนจากคอมไพเลอร์หากคุณสร้างฟิวเจอร์ขึ้นมาแต่ไม่ได้นำไปใช้งาน) สิ่งนี้อาจทำให้คุณนึกถึงเรื่องอิเทอเรเตอร์ (iterator) ในหัวข้อ“ประมวลผลลำดับรายการด้วยอิเทอเรเตอร์” ในบทที่ 13 อิเทอเรเตอร์จะไม่ทำอะไรจนกว่าคุณจะเรียกเมธอด next—ไม่ว่าจะเรียกโดยตรง หรือผ่านลูป for หรือเมธอดอย่าง map ที่เรียกใช้ next อยู่เบื้องหลัง ในทำนองเดียวกัน ฟิวเจอร์จะไม่ทำสิ่งใดจนกว่าคุณจะสั่งให้ทำงานอย่างชัดเจน พฤติกรรมแบบเลซี่นี้ช่วยให้ Rust หลีกเลี่ยงการรันโค้ด async จนกว่าจะถึงเวลาที่จำเป็นจริงๆ
หมายเหตุ: พฤติกรรมนี้แตกต่างจากสิ่งที่เราเห็นเมื่อใช้
thread::spawnในหัวข้อ“การสร้างเธรดใหม่ด้วย spawn” ในบทที่ 16 ซึ่งโคลเชอร์ที่เราส่งข้ามไปยังอีกเธรดหนึ่งจะเริ่มทำงานทันที และยังแตกต่างจากวิธีที่ภาษาอื่นๆ หลายภาษาจัดการกับ async อีกด้วย แต่สิ่งนี้มีความสำคัญอย่างยิ่งต่อการรับประกันด้านประสิทธิภาพของ Rust เช่นเดียวกับในกรณีของอิเทอเรเตอร์
เมื่อได้ response_text มาแล้ว เราสามารถพาร์ส (parse) มันให้เป็นอินสแตนซ์ของชนิดข้อมูล Html ได้โดยใช้ Html::parse ทำให้แทนที่จะเป็นเพียงสตริงดิบ ตอนนี้เรามีชนิดข้อมูลที่ช่วยจัดการ HTML ในฐานะโครงสร้างข้อมูลที่สมบูรณ์ยิ่งขึ้น โดยเฉพาะอย่างยิ่ง เราสามารถใช้เมธอด select_first เพื่อค้นหาเอลิเมนต์แรกที่ตรงกับตัวเลือก CSS (CSS selector) ที่กำหนด การส่งสตริง "title" เข้าไปจะทำให้เราได้เอลิเมนต์ <title> ตัวแรกในเอกสาร (หากมีอยู่) และเนื่องจากอาจไม่มีเอลิเมนต์ที่ตรงกับเงื่อนไขเลย เมธอด select_first จึงคืนค่าเป็น Option<ElementRef> สุดท้าย เราใช้เมธอด Option::map ซึ่งเปิดโอกาสให้เราจัดการกับค่าภายใน Option หากมีค่านั้นอยู่ และไม่ทำอะไรหากไม่มี (เราจะใช้คำสั่ง match ในจุดนี้ก็ได้ แต่การใช้ map จะตรงกับสำนวนของ Rust มากกว่า) ในบอดี้ของฟังก์ชันที่เราส่งให้ map เราเรียก inner_html บน title เพื่อดึงเนื้อหาภายในออกมา ซึ่งเป็น String และเมื่อทำทุกขั้นตอนเสร็จสิ้น เราก็จะได้ค่าชนิด Option<String> ออกมา
โปรดสังเกตว่าคีย์เวิร์ด await ของ Rust จะวางอยู่_ต่อท้าย (postfix)_ นิพจน์ที่คุณต้องการ await ไม่ใช่วางไว้ข้างหน้า ซึ่งอาจแตกต่างจากสิ่งที่คุณคุ้นเคยหากเคยใช้ async ในภาษาอื่น แต่สำหรับ Rust แล้ว รูปแบบนี้ช่วยให้การเรียกเมธอดต่อกันเป็นลูกโซ่ (method chaining) ทำได้อย่างลื่นไหลและสวยงามขึ้นมาก ส่งผลให้เราสามารถปรับเปลี่ยนบอดี้ของฟังก์ชัน page_title ให้เชื่อมการเรียกฟังก์ชัน trpl::get และ text เข้าด้วยกันโดยมี await คั่นกลางได้ ดังแสดงในลิสติ้ง 17-2
extern crate trpl; // required for mdbook test
use trpl::Html;
fn main() {
// TODO: we'll add this next!
}
async fn page_title(url: &str) -> Option<String> {
let response_text = trpl::get(url).await.text().await;
Html::parse(&response_text)
.select_first("title")
.map(|title| title.inner_html())
}
เท่านี้เราก็เขียนฟังก์ชัน async ฟังก์ชันแรกของเราสำเร็จแล้ว! แต่ก่อนที่จะเพิ่มโค้ดใน main เพื่อเรียกใช้งานมัน เรามาทำความเข้าใจสิ่งที่เราเพิ่งเขียนไปและความหมายเบื้องหลังของมันกันสักนิด
เมื่อ Rust พบ_บล็อก_ที่กำกับด้วยคีย์เวิร์ด async มันจะคอมไพล์บล็อกนั้นให้กลายเป็นชนิดข้อมูลนิรนาม (anonymous type) เฉพาะตัวที่อิมพลีเมนต์เทรต Future และเมื่อ Rust พบ_ฟังก์ชัน_ที่กำกับด้วย async มันจะคอมไพล์ฟังก์ชันนั้นให้กลายเป็นฟังก์ชันธรรมดา (ไม่ใช่ async) ที่มีเนื้อหาบอดี้เป็นบล็อก async โดยที่ชนิดข้อมูลที่คืนกลับของฟังก์ชัน async ก็คือชนิดข้อมูลนิรนามที่คอมไพเลอร์สร้างขึ้นสำหรับบล็อก async นั้นนั่นเอง
ดังนั้น การเขียน async fn จึงเทียบเท่ากับการเขียนฟังก์ชันที่คืนค่าเป็น_ฟิวเจอร์_ของชนิดข้อมูลที่คืนกลับมา สำหรับคอมไพเลอร์แล้ว นิยามฟังก์ชันอย่าง async fn page_title ในลิสติ้ง 17-1 จะเทียบเท่ากับฟังก์ชันธรรมดาที่นิยามในลักษณะนี้โดยประมาณ:
#![allow(unused)]
fn main() {
extern crate trpl; // required for mdbook test
use std::future::Future;
use trpl::Html;
fn page_title(url: &str) -> impl Future<Output = Option<String>> {
async move {
let text = trpl::get(url).await.text().await;
Html::parse(&text)
.select_first("title")
.map(|title| title.inner_html())
}
}
}
เรามาไล่ดูแต่ละส่วนของฟังก์ชันเวอร์ชันที่แปลงแล้วนี้กัน:
- ฟังก์ชันนี้ใช้ไวยากรณ์
impl Traitที่เราเคยกล่าวถึงในบทที่ 10 ในหัวข้อ“การใช้เทรตเป็นพารามิเตอร์” - ค่าที่คืนกลับมานั้นอิมพลีเมนต์เทรต
Futureโดยมีชนิดข้อมูลสัมพันธ์ (associated type) ชื่อOutputและโปรดสังเกตว่าชนิดข้อมูลของOutputคือOption<String>ซึ่งตรงกับชนิดข้อมูลที่คืนกลับดั้งเดิมของpage_titleในเวอร์ชันasync fn - โค้ดทั้งหมดในบอดี้ของฟังก์ชันเดิมจะถูกห่อหุ้มไว้ในบล็อก
async moveอย่าลืมว่าบล็อกใน Rust คือนิพจน์ (expression) ดังนั้นบล็อกทั้งหมดนี้จึงเป็นนิพจน์ที่ฟังก์ชันคืนค่ากลับออกไป - บล็อก async นี้ให้ผลลัพธ์เป็นค่าชนิด
Option<String>ตามที่เพิ่งอธิบายไป ซึ่งค่านั้นตรงกับชนิดข้อมูลOutputในชนิดคืนค่าของฟังก์ชันพอดี เช่นเดียวกับบล็อกอื่นๆ ที่คุณเคยพบเห็น - บอดี้ของฟังก์ชันใหม่กลายเป็นบล็อก
async moveก็เนื่องมาจากลักษณะการนำพารามิเตอร์urlไปใช้งาน (เราจะมาพูดคุยเรื่องความแตกต่างระหว่างasyncกับasync moveกันอย่างละเอียดอีกครั้งในบทนี้)
ตอนนี้เราสามารถเรียก page_title ใน main ได้แล้ว
การเรียกใช้ฟังก์ชัน async ด้วยรันไทม์
ในการเริ่มต้น เราจะดึงชื่อเรื่องของหน้าเพจเพียงหน้าเดียวก่อน ดังแสดงในลิสติ้ง 17-3 แต่น่าเสียดายที่โค้ดนี้จะยังคอมไพล์ไม่ผ่าน
extern crate trpl; // required for mdbook test
use trpl::Html;
async fn main() {
let args: Vec<String> = std::env::args().collect();
let url = &args[1];
match page_title(url).await {
Some(title) => println!("The title for {url} was {title}"),
None => println!("{url} had no title"),
}
}
async fn page_title(url: &str) -> Option<String> {
let response_text = trpl::get(url).await.text().await;
Html::parse(&response_text)
.select_first("title")
.map(|title| title.inner_html())
}
เราทำตามรูปแบบเดิมที่เคยใช้รับอาร์กิวเมนต์จากบรรทัดคำสั่งในหัวข้อ“รับอาร์กิวเมนต์จากบรรทัดคำสั่ง” ในบทที่ 12 จากนั้นจึงส่งอาร์กิวเมนต์ URL ให้แก่ page_title แล้วทำการ await ผลลัพธ์ และเนื่องจากค่าที่ฟิวเจอร์ส่งกลับมาเป็น Option<String> เราจึงใช้นิพจน์ match เพื่อพิมพ์ข้อความที่แตกต่างกันตามเงื่อนไขว่าหน้าเพจนั้นมี <title> หรือไม่
จุดเดียวที่เราสามารถใช้คีย์เวิร์ด await ได้คือภายในฟังก์ชันหรือบล็อกที่เป็น async เท่านั้น และ Rust จะไม่อนุญาตให้เรากำกับฟังก์ชันพิเศษอย่าง main ด้วย async เป็นอันขาด
error[E0752]: `main` function is not allowed to be `async`
--> src/main.rs:6:1
|
6 | async fn main() {
| ^^^^^^^^^^^^^^^ `main` function is not allowed to be `async`
เหตุผลที่ main ไม่สามารถเป็น async ได้ก็เพราะโค้ดแบบ async จำเป็นต้องมี_รันไทม์ (runtime)_ ซึ่งเป็นเครต Rust ที่ทำหน้าที่ดูแลจัดการรายละเอียดในการประมวลผลโค้ดแบบอะซิงโครนัส ฟังก์ชัน main ของโปรแกรมสามารถ_เริ่มต้นสร้าง_รันไทม์ขึ้นมาได้ แต่ตัวฟังก์ชัน main เองไม่ได้เป็นรันไทม์ (เราจะได้เห็นเหตุผลเพิ่มเติมในอีกไม่ช้า) ทุกโปรแกรมของ Rust ที่ประมวลผลโค้ด async จะต้องมีอย่างน้อยหนึ่งจุดที่ทำหน้าที่สร้างรันไทม์เพื่อนำฟิวเจอร์ไปรันต่อ
ภาษาโปรแกรมส่วนใหญ่ที่รองรับ async มักจะแถมรันไทม์มาให้พร้อมในตัวภาษา แต่ Rust ไม่ได้ทำเช่นนั้น กลับเปิดให้มีรันไทม์ async หลากหลายตัวให้เลือกใช้ตามความเหมาะสม โดยแต่ละตัวจะมีการชั่งน้ำหนักข้อดีข้อเสีย (trade-offs) ที่เหมาะกับกรณีการใช้งานที่แตกต่างกัน ตัวอย่างเช่น เว็บเซิร์ฟเวอร์ที่ต้องการปริมาณงานสูง (high-throughput) ซึ่งทำงานบนเครื่องที่มีหลายซีพียูคอร์และแรมปริมาณมหาศาล ย่อมมีความต้องการที่แตกต่างไปจากไมโครคอนโทรลเลอร์ที่มีเพียงคอร์เดียว แรมน้อยนิด และไม่สามารถจัดสรรหน่วยความจำบนฮีปได้ นอกจากนี้ เครตที่จัดเตรียมรันไทม์เหล่านั้นมักจะมีฟังก์ชันการทำงานพื้นฐานเวอร์ชัน async เช่น ระบบ I/O สำหรับไฟล์หรือเครือข่ายมาให้ใช้งานควบคู่กันด้วย
ณ จุดนี้ และตลอดทั้งบทที่เหลือ เราจะใช้ฟังก์ชัน block_on จากเครต trpl ซึ่งจะรับฟิวเจอร์เข้ามาเป็นอาร์กิวเมนต์ แล้วทำการบล็อกเธรดปัจจุบันเอาไว้จนกว่าฟิวเจอร์นั้นจะทำงานเสร็จสิ้นสมบูรณ์ เบื้องหลังแล้ว การเรียก block_on จะเตรียมรันไทม์ขึ้นมาโดยใช้เครต tokio เพื่อนำฟิวเจอร์ที่ส่งเข้ามาไปประมวลผล (โดยพฤติกรรมของ block_on ในเครต trpl จะคล้ายคลึงกับฟังก์ชัน block_on ของเครตรันไทม์อื่นๆ) และเมื่อฟิวเจอร์ทำงานเสร็จสิ้น ฟังก์ชัน block_on ก็จะคืนค่าที่ฟิวเจอร์นั้นสร้างขึ้นออกมา
เราอาจจะส่งฟิวเจอร์ที่ได้จาก page_title เข้าไปยัง block_on โดยตรงก็ได้ และเมื่อมันทำงานเสร็จ เราก็สามารถใช้ pattern matching กับ Option<String> ตามที่เคยพยายามทำในลิสติ้ง 17-3 ทว่าสำหรับตัวอย่างส่วนใหญ่ในบทนี้ (รวมถึงโค้ด async ในชีวิตจริงเกือบทั้งหมด) เรามักจะทำอะไรมากกว่าแค่การเรียกฟังก์ชัน async เพียงฟังก์ชันเดียว ดังนั้นเราจึงจะส่งบล็อก async เข้าไปแทน แล้วทำการ await ผลลัพธ์จากการเรียก page_title อย่างชัดเจน ดังแสดงในลิสติ้ง 17-4
extern crate trpl; // required for mdbook test
use trpl::Html;
fn main() {
let args: Vec<String> = std::env::args().collect();
trpl::block_on(async {
let url = &args[1];
match page_title(url).await {
Some(title) => println!("The title for {url} was {title}"),
None => println!("{url} had no title"),
}
})
}
async fn page_title(url: &str) -> Option<String> {
let response_text = trpl::get(url).await.text().await;
Html::parse(&response_text)
.select_first("title")
.map(|title| title.inner_html())
}
เมื่อเรารันโค้ดนี้ เราจะได้พฤติกรรมที่เราคาดหวังไว้ตั้งแต่แรก:
$ cargo run -- "https://www.rust-lang.org"
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.05s
Running `target/debug/async_await 'https://www.rust-lang.org'`
The title for https://www.rust-lang.org was
Rust Programming Language
ในที่สุดเราก็มีโค้ด async ที่ทำงานได้จริงแล้ว! แต่ก่อนที่เราจะเพิ่มโค้ดเพื่อจับเว็บสองแห่งมาประชันความเร็วกัน เรามาแวะทำความเข้าใจกลไกการทำงานของฟิวเจอร์กันอีกสักเล็กน้อย
จุด await (await point) แต่ละจุด—กล่าวคือ ทุกๆ จุดในโค้ดที่มีการใช้คีย์เวิร์ด await—เป็นตัวแทนของตำแหน่งที่การควบคุมจะถูกส่งมอบกลับคืนให้แก่รันไทม์ และเพื่อให้กลไกนี้ทำงานได้ Rust จำเป็นต้องบันทึกและติดตามสถานะทั้งหมดที่เกี่ยวข้องในบล็อก async เอาไว้ เพื่อเปิดทางให้รันไทม์สามารถสลับไปเริ่มงานอื่นได้ แล้วค่อยย้อนกลับมาเดินหน้างานแรกต่อเมื่อพร้อม ซึ่งสิ่งนี้ก็คือสเตตแมชชีน (state machine) ที่ซ่อนอยู่เบื้องหลัง เสมือนกับว่าคุณได้เขียน enum ขึ้นมาเพื่อคอยบันทึกสถานะปัจจุบัน ณ แต่ละจุด await ดังนี้:
#![allow(unused)]
fn main() {
extern crate trpl; // required for mdbook test
enum PageTitleFuture<'a> {
Initial { url: &'a str },
GetAwaitPoint { url: &'a str },
TextAwaitPoint { response: trpl::Response },
}
}
ทว่าการมานั่งเขียนโค้ดจัดการเปลี่ยนสถานะไปมาระหว่างแต่ละสเตตด้วยตนเองคงเป็นเรื่องที่น่าเบื่อหน่ายและเสี่ยงต่อความผิดพลาดอย่างยิ่ง โดยเฉพาะอย่างยิ่งเมื่อคุณต้องเพิ่มเติมฟังก์ชันการทำงานและสถานะใหม่ๆ ให้แก่โค้ดในภายหลัง โชคดีที่คอมไพเลอร์ของ Rust จะสร้างและจัดการโครงสร้างข้อมูลของสเตตแมชชีนสำหรับโค้ด async ให้โดยอัตโนมัติ กฎการยืมและกฎความเป็นเจ้าของตามปกติของ Rust ยังคงมีผลบังคับใช้อย่างสมบูรณ์กับโครงสร้างข้อมูลเหล่านี้ และน่ายินดีที่คอมไพเลอร์ยังคอยตรวจสอบกฎเหล่านั้นให้เราพร้อมทั้งให้ข้อความแจ้งข้อผิดพลาดที่เป็นประโยชน์อย่างมาก ซึ่งเราจะได้เห็นตัวอย่างข้อผิดพลาดเหล่านี้ในบทต่อไป
และในท้ายที่สุด ย่อมต้องมีผู้ที่นำสเตตแมชชีนนี้ไปประมวลผล ซึ่งผู้นั้นก็คือรันไทม์ (นี่คือเหตุผลว่าทำไมคุณจึงอาจพบคำว่า เอ็กซิคิวเตอร์ (executor) เมื่อศึกษารันไทม์ โดยเอ็กซิคิวเตอร์คือส่วนประกอบของรันไทม์ที่รับผิดชอบการประมวลผลโค้ด async โดยตรง)
ตอนนี้คุณคงเข้าใจแล้วว่าทำไมคอมไพเลอร์จึงห้ามไม่ให้เราประกาศฟังก์ชัน main เป็นฟังก์ชัน async ในลิสติ้ง 17-3 เพราะหาก main เป็นฟังก์ชัน async ย่อมต้องมีระบบอื่นเข้ามาคอยจัดการสเตตแมชชีนของฟิวเจอร์ที่ main ส่งกลับออกมา แต่ฟังก์ชัน main คือจุดเริ่มต้นของโปรแกรมทั้งหมด! ด้วยเหตุนี้ เราจึงต้องเรียกฟังก์ชัน trpl::block_on ภายใน main เพื่อสร้างรันไทม์ขึ้นมา แล้วสั่งรันฟิวเจอร์ที่บล็อก async ส่งกลับมาจนเสร็จสิ้น
หมายเหตุ: รันไทม์บางตัวมีมาโครที่ช่วยให้คุณ_สามารถ_เขียนฟังก์ชัน
mainแบบ async ได้ โดยเบื้องหลังแล้ว มาโครเหล่านั้นจะแปลงasync fn main() { ... }ให้กลายเป็นfn mainแบบปกติ ซึ่งทำสิ่งเดียวกันกับที่เราลงมือทำด้วยตนเองในลิสติ้ง 17-4 นั่นคือการเรียกฟังก์ชันเพื่อรันฟิวเจอร์จนเสร็จสิ้นในแบบเดียวกับที่trpl::block_onทำ
คราวนี้ เรามานำชิ้นส่วนทั้งหมดมาประกอบเข้าด้วยกัน แล้วดูวิธีเขียนโค้ดให้ทำงานพร้อมกัน (concurrent) กันดีกว่า
การแข่งสอง URL เข้าด้วยกันแบบพร้อมกัน
ในลิสติ้ง 17-5 เราจะเรียกใช้ page_title ด้วย URL สองรายการที่แตกต่างกันซึ่งรับมาจากบรรทัดคำสั่ง แล้วนำทั้งสองมารันประชันกันโดยเลือกใช้ผลลัพธ์ของฟิวเจอร์ที่ทำงานเสร็จก่อน
extern crate trpl; // required for mdbook test
use trpl::{Either, Html};
fn main() {
let args: Vec<String> = std::env::args().collect();
trpl::block_on(async {
let title_fut_1 = page_title(&args[1]);
let title_fut_2 = page_title(&args[2]);
let (url, maybe_title) =
match trpl::select(title_fut_1, title_fut_2).await {
Either::Left(left) => left,
Either::Right(right) => right,
};
println!("{url} returned first");
match maybe_title {
Some(title) => println!("Its page title was: '{title}'"),
None => println!("It had no title."),
}
})
}
async fn page_title(url: &str) -> (&str, Option<String>) {
let response_text = trpl::get(url).await.text().await;
let title = Html::parse(&response_text)
.select_first("title")
.map(|title| title.inner_html());
(url, title)
}
เราเริ่มต้นด้วยการเรียก page_title สำหรับแต่ละ URL ที่ผู้ใช้ระบุเข้ามา แล้วเก็บผลลัพธ์ของฟิวเจอร์ไว้ในตัวแปร title_fut_1 และ title_fut_2 อย่าลืมว่าฟิวเจอร์เหล่านี้จะยังไม่เริ่มทำงานใดๆ เพราะฟิวเจอร์มีลักษณะแบบเลซี่และเรายังไม่ได้ทำการ await พวกมัน จากนั้นเราจึงส่งฟิวเจอร์ทั้งสองตัวไปยัง trpl::select ซึ่งจะคืนค่าที่ระบุว่าฟิวเจอร์ตัวใดทำงานเสร็จเป็นอันดับแรก
หมายเหตุ: เบื้องหลังการทำงานนั้น
trpl::selectถูกสร้างขึ้นบนฟังก์ชันselectที่มีความเป็นทั่วไปมากกว่าในเครตfuturesโดยฟังก์ชันselectของเครตfuturesสามารถทำอะไรได้หลายอย่างที่trpl::selectทำไม่ได้ แต่ก็มีความซับซ้อนเพิ่มขึ้นที่เราสามารถละไว้ก่อนได้ในตอนนี้
เนื่องจากฟิวเจอร์ตัวใดตัวหนึ่งย่อมสามารถ “ชนะ” ได้อย่างถูกต้องตามปกติ การคืนค่าเป็น Result จึงไม่สมเหตุสมผล ด้วยเหตุนี้ trpl::select จึงคืนค่าเป็นชนิดข้อมูลที่เราไม่เคยเห็นมาก่อน นั่นคือ trpl::Either ชนิดข้อมูล Either มีความคล้ายคลึงกับ Result ตรงที่มีสองกรณี (variant) แต่ต่างกันตรงที่ Either ไม่ได้แฝงความหมายของความสำเร็จหรือความล้มเหลวเอาไว้เลย แต่มันใช้ Left และ Right เพื่อบ่งบอกถึงความหมายว่า “อย่างใดอย่างหนึ่ง”:
#![allow(unused)]
fn main() {
enum Either<A, B> {
Left(A),
Right(B),
}
}
ฟังก์ชัน select จะคืนค่า Left พร้อมข้อมูลเอาต์พุตของฟิวเจอร์นั้นหากอาร์กิวเมนต์แรกเป็นฝ่ายชนะ และคืนค่า Right พร้อมข้อมูลเอาต์พุตของฟิวเจอร์ตัวที่สองหากตัว_นั้น_เป็นฝ่ายชนะ ซึ่งสอดคล้องกับลำดับของอาร์กิวเมนต์ตอนเรียกฟังก์ชัน นั่นคืออาร์กิวเมนต์แรกอยู่ทางซ้าย (Left) ของอาร์กิวเมนต์ที่สอง (Right)
นอกจากนี้ เรายังได้อัปเดตให้ page_title คืนค่า URL เดิมที่ส่งเข้าไปกลับออกมาด้วย เพื่อที่ว่าหากหน้าเพจที่เสร็จก่อนไม่มี <title> ให้ดึงออกมา เราก็ยังสามารถพิมพ์ข้อความที่สื่อความหมายชัดเจนได้ และเมื่อมีข้อมูลดังกล่าวพร้อมแล้ว เราก็ปิดท้ายด้วยการอัปเดตเอาต์พุตของ println! เพื่อแสดงให้เห็นว่า URL ใดทำงานเสร็จก่อน และแท็ก <title> ของเว็บเพจนั้นคืออะไร (หากมี)
ในตอนนี้คุณได้สร้างเว็บสแครปเปอร์ขนาดเล็กที่ใช้งานได้จริงสำเร็จแล้ว! ลองเลือก URL สัก 2-3 เว็บแล้วทดลองรันเครื่องมือบรรทัดคำสั่งนี้ดู คุณอาจพบว่าบางเว็บไซต์เร็วกว่าอีกเว็บหนึ่งอย่างสม่ำเสมอ ในขณะที่บางคู่อาจผลัดกันเร็วขึ้นอยู่กับการรันแต่ละครั้ง แต่ที่สำคัญที่สุดคือ คุณได้เรียนรู้พื้นฐานของการทำงานกับฟิวเจอร์แล้ว และตอนนี้เราก็พร้อมที่จะเจาะลึกถึงสิ่งต่างๆ ที่เราสามารถทำได้ด้วย async ต่อไป