Learn Rust Coding · บทเรียน

รู้จัก Async/Await

เรียนรู้พื้นฐานของฟังก์ชัน `async` และนิพจน์ `await` เพื่อเขียนโค้ดแบบอะซิงโครนัสที่ไม่หยุดรอ

รู้จัก Async/Await เป็นบทเรียน Learn Rust Coding ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 3 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Learn Rust Coding และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Learn Rust Coding มีบทเรียนทั้งหมด 3 บทเรียน

เหตุใดจึงต้องเขียนโปรแกรมแบบอะซิงโครนัส

ในการเขียนโปรแกรม งานต่าง ๆ มักเกี่ยวข้องกับการรอ เช่น รอให้ไฟล์โหลด รอคำขอเครือข่ายเสร็จสิ้น หรือรอให้การค้นหาฐานข้อมูลคืนผลลัพธ์

ตามแนวทางเดิม โปรแกรมจะ หยุดรอ ระหว่างช่วงเวลาเหล่านี้ ซึ่งหมายความว่าจะหยุดการดำเนินการอื่นทั้งหมดจนกว่างานจะเสร็จ ทำให้แอปพลิเคชันทำงานช้าและไม่ตอบสนอง

เมื่อโค้ดต้องรอ...

ลองพิจารณาตัวอย่างง่าย ๆ ของการดำเนินการที่หยุดรอ โปรแกรมจะหยุดเป็นเวลา 2 วินาทีก่อนพิมพ์ข้อความที่สอง

ลองเรียกใช้ดู:

use std::thread;
use std::time::Duration;

fn main() {
  println!("Starting a blocking task...");
  thread::sleep(Duration::from_secs(2)); // This blocks!
  println!("Blocking task finished!");
}

ต้นทุนของการรอ

ในตัวอย่างก่อนหน้านี้ โปรแกรมทั้งหมดต้องรอ หากนี่เป็นเซิร์ฟเวอร์เว็บ ก็หมายความว่าในขณะที่คำขอของผู้ใช้รายหนึ่งกำลังรอฐานข้อมูล ผู้ใช้รายอื่นจะไม่ได้รับบริการ!

การเขียนโปรแกรมแบบอะซิงโครนัส ช่วยให้โปรแกรมเริ่มงานที่ใช้เวลานาน แล้วไปทำงานอื่นต่อแทนที่จะรอ เมื่อ งานที่ใช้เวลานานเสร็จพร้อม โปรแกรมจึงกลับมาดำเนินการต่อได้

แนวทางอะซิงโครนัสของ Rust

Rust มีความสามารถของภาษาที่ทรงพลังสำหรับการเขียนโปรแกรมแบบอะซิงโครนัส ได้แก่ คีย์เวิร์ด async และ await

ฟังก์ชัน async เป็นฟังก์ชันพิเศษที่สามารถหยุดชั่วคราวและทำงานต่อได้
.await ใช้ภายในฟังก์ชัน async เพื่อรอให้งานอะซิงโครนัสอื่นเสร็จ โดยไม่หยุดทั้งโปรแกรม

การกำหนดฟังก์ชัน `async`

คุณประกาศฟังก์ชันอะซิงโครนัสโดยเพิ่มคีย์เวิร์ด async ไว้หน้า fn ฟังก์ชัน async จะคืนค่าเป็น Future เสมอ

Future คือค่าที่อาจยังไม่พร้อมใช้งาน โดยแสดงถึงการคำนวณที่จะสร้างผลลัพธ์ในภายหลัง

async fn my_async_task() -> u32 {
  // This task will eventually return 42
  42
}

การหยุดชั่วคราวด้วย `.await`

คีย์เวิร์ด .await คือสิ่งที่ทำให้การเขียนโปรแกรมแบบอะซิงโครนัสไม่ต้องหยุดรอ เมื่อคุณใช้ .await กับ Future ฟังก์ชัน async ของคุณจะ:

หยุดการทำงานของตัวเองชั่วคราว
เปิดโอกาสให้โปรแกรมทำงานอื่น
ทำงานต่อเมื่อ Future ที่รออยู่พร้อม

ลองนึกภาพว่าเป็นการกดปุ่มหยุดชั่วคราวบนงานปัจจุบัน ขณะที่อีกงานหนึ่งกำลังทำงานจนเสร็จ

การเรียกใช้โค้ดอะซิงโครนัส: ตัวดำเนินการ

ฟังก์ชัน async จะคืนค่าเป็น Future แต่จะยังไม่เรียกใช้โค้ดภายในทันที Future มีลักษณะ ทำงานเมื่อถูกเรียกใช้

หากต้องการเรียกใช้ฟังก์ชัน async และดำเนินการ Future จริง คุณต้องมี ตัวดำเนินการ สำหรับตัวอย่างง่าย ๆ เราสามารถใช้ futures::executor::block_on ซึ่งจะดำเนินการ Future จนเสร็จบนเธรดปัจจุบัน

โปรแกรม `async`/`await` แรกของคุณ

นี่คือวิธีที่ async, await และตัวดำเนินการแบบง่ายทำงานร่วมกัน โปรดสังเกตว่ามีการใช้ block_on ใน main เพื่อเริ่มกระบวนการอะซิงโครนัส

ตัวอย่างนี้จำลองการหน่วงเวลาแบบอะซิงโครนัสโดยไม่หยุดเธรดของฟังก์ชัน main (ในเชิงแนวคิด; แต่ block_on เองจะหยุดรอจนกว่า Future จะเสร็จ ขณะที่งานอะซิงโครนัสจะยอมคืนการควบคุม)

use futures::executor::block_on;
use std::time::Duration;

async fn learn_and_wait() {
  println!("Learning asynchronously...");
  // Simulate an async operation that takes time
  // In a real app, this would be an I/O op
  tokio::time::sleep(Duration::from_secs(1)).await;
  println!("Finished learning!");
}

fn main() {
  println!("Starting main function.");
  block_on(learn_and_wait());
  println!("Main function finished.");
}

ทำความเข้าใจเทรต `Future`

เมื่อคุณเขียน async fn my_func() จริง ๆ แล้ว Rust จะแปลงสิ่งนี้เป็นเครื่องสถานะที่ใช้งานเทรต Future ได้

เทรต Future มีเมธอดหลักหนึ่งรายการคือ poll ซึ่งตัวดำเนินการจะเรียกซ้ำ ๆ เพื่อตรวจสอบว่างานพร้อมดำเนินการต่อหรือไม่ เมื่อมีการใช้ .await กับ Future ระบบจะแจ้งให้ตัวดำเนินการตรวจสอบ Future อื่นจนกว่าจะเสร็จ

ตรวจสอบความเข้าใจ: พื้นฐาน Async/Await

คุณได้เรียนรู้พื้นฐานของ async และ await แล้ว มาดูกันว่าคุณสามารถระบุบทบาทสำคัญของแต่ละส่วนได้หรือไม่

ทบทวนและขั้นตอนถัดไป

ยอดเยี่ยมครับ! คุณได้ก้าวแรกสู่การเขียนโปรแกรม Rust แบบอะซิงโครนัสแล้ว

เราได้เห็นว่าบล็อกโค้ดแบบซิงโครนัสทำให้โปรแกรมต้องรอ
โค้ดแบบอะซิงโครนัสช่วยให้ทาสก์ทำงานพร้อมกันได้โดยไม่บล็อกการทำงาน
คีย์เวิร์ด async ใช้ประกาศฟังก์ชันแบบอะซิงโครนัส ซึ่งส่งคืน Future
คีย์เวิร์ด .await จะหยุดชั่วคราวฟังก์ชัน async จนกว่า Future จะพร้อม
จำเป็นต้องมีตัวประมวลผล (เช่น block_on) เพื่อเรียกใช้ Futures

ถัดไป เราจะเจาะลึก Tokio ซึ่งเป็นรันไทม์และระบบนิเวศอันทรงพลังสำหรับสร้างแอปพลิเคชันอะซิงโครนัสที่ใช้งานจริงด้วย Rust!

คำถามที่พบบ่อย

บทเรียน “รู้จัก Async/Await” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “รู้จัก Async/Await” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Learn Rust Coding ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Learn Rust Coding มีบทเรียนทั้งหมด 3 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “รู้จัก Async/Await”

เรียนรู้พื้นฐานของฟังก์ชัน `async` และนิพจน์ `await` เพื่อเขียนโค้ดแบบอะซิงโครนัสที่ไม่หยุดรอ คุณปฏิบัติ Learn Rust Coding ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Learn Rust Coding หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Learn Rust Coding บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 3 บทเรียน

บทเรียน “รู้จัก Async/Await” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Learn Rust Coding นี้ได้ไหม

ได้ บทเรียน Learn Rust Coding ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ Learn Rust Coding