การใช้งาน Asynchronous programming ในภาษา Rust แบบง่ายๆ พร้อมตัวอย่าง

การเขียนโปรแกรมแบบ Asynchronous หรือที่หลายคนอาจคุ้นเคยในชื่อของ Async Programming นั้นเป็นกลไกการทำงานที่ช่วยให้โปรแกรมสามารถดำเนินการต่อไปได้โดยไม่ต้องรอให้คำสั่งหนึ่งๆเสร็จสิ้นลง ซึ่งในภาษา Rust ก็มีการสนับสนุนการเขียนโปรแกรมแบบแอสิงโครนัสผ่าน futures และ async-await ที่มาพร้อมกับความสามารถในการจัดการ tasks แบบไม่บล็อครหัสโปรแกรม หรือ Non-blocking I/O นั่นเอง

ตัวอย่าง CODE 1: การดึงข้อมูลแบบ Async

ในตัวอย่างแรกนี้ เราจะลองเขียนโปรแกรมแบบ Async ใน Rust ที่สำหรับดึงข้อมูลจากการใช้ HTTP request โดยใช้แพ็กเกจ `reqwest` ที่มีการสนับสนุนการทำงานแบบ Async.

 use reqwest; // เพิ่ม dependency ใน Cargo.toml สำหรับแพ็กเกจนี้
use tokio; // Runtime สำหรับ async

#[tokio::main]
async fn main() {
    let body = reqwest::get("https://www.example.com")
        .await // await จะรอการคำตอบโดยไม่บล็อกส่วนอื่นๆของโปรแกรม
        .unwrap()
        .text()
        .await
        .unwrap();

    println!("body = {:?}", body);
}

ตัวอย่าง CODE 2: การทำงานพร้อมกันหลาย Task

หากคุณต้องการจัดการหลาย tasks พร้อมๆกัน เช่นการเชื่อมต่อกับหลาย databases ในเวลาเดียวกัน คุณสามารถใช้ `futures::join!` ซึ่งจะรอให้ทุก tasks เสร็จทั้งหมดก่อนจึงจะดำเนินการต่อ.

 use futures::join; // ต้องเพิ่ม futures crate ใน Cargo.toml

async fn task_one() -> String {
    // มีการจำลองการทำงานที่ใช้เวลานาน
    tokio::time::delay_for(tokio::time::Duration::from_secs(2)).await;
    "task one complete".to_string()
}

async fn task_two() -> String {
    // มีการจำลองการทำงานที่ใช้เวลานาน
    tokio::time::delay_for(tokio::time::Duration::from_secs(2)).await;
    "task two complete".to_string()
}

#[tokio::main]
async fn main() {
    let (result_one, result_two) = join!(task_one(), task_two());

    println!("{}, and {}", result_one, result_two);
}

ตัวอย่าง CODE 3: การสร้าง Custom Future

ใน Rust, เราสามารถสร้าง Future ของเราเองได้ เพื่อรองรับการทำงานที่ซับซ้อนมากขึ้น เช่น การรองรับข้อมูลที่ต้องการการคำนวณที่ซับซ้อนก่อนจะส่งเป็น Output.

 use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};

struct MyFuture {
    // ในที่นี้เป็นตัวอย่างเพื่อการประกอบการสอน เราจะใช้ข้อมูลแบบง่าย
    pub value: i32,
}

impl Future for MyFuture {
    type Output = String;

    fn poll(self: Pin<&mut Self>, _cx: &mut Context) -> Poll<Self::Output> {
        if self.value == 42 {
            // สมมติว่าเราต้องการค่า 42 เป็นการจบ Future
            Poll::Ready("The answer to life, the universe and everything!".to_string())
        } else {
            // ถ้าไม่ใช่ 42, ตัว Future นี้ยังไม่จบ
            Poll::Pending
        }
    }
}

#[tokio::main]
async fn main() {
    let my_future = MyFuture { value: 42 };
    let result = my_future.await;
    println!("{}", result);
}

Usecase ในโลกจริงของ Asynchronous Programming

หนึ่งใน usecase ที่เห็นได้ชัดเจนที่สุดในการใช้งาน Async Programming คือการพัฒนา Web Server ที่ต้องรับการเชื่อมต่อพร้อมกันจำนวนมาก หรือทำงานร่วมกับ External API โดยไม่ต้องรอการตอบสนองจากการเรียกใช้งานนั้นๆ ซึ่งจะช่วยปรับปรุง performance และ scalability ของแอปพลิเคชันได้อย่างมาก

Asynchronous Programming ยังสามารถใช้ประโยชน์ในการพัฒนาระบบ IoT ที่ต้องการการตอบสนองคำสั่งแบบ Real-time หรือในระบบ Microservices ที่มีการสื่อสารผ่านข้อความหรือ API ต่างๆ แบบไม่ต้องรอการทำข้อความให้เรียบร้อย

การเรียนรู้และการทำความเข้าใจกับ Asynchronous Programming จะช่วยเพิ่มอาวุธในการเขียนโค้ดให้คุณมีประสิทธิภาพมากขึ้น และที่ EPT (Expert-Programming-Tutor) เรามีคอร์สเรียนการเขียนโปรแกรมด้วยภาษา Rust ที่จะช่วยนำทางคุณผ่านทักษะเหล่านี้พร้อมกับการปฏิบัติจริง ไม่ว่าจะเป็นการเรียนรู้หลักการทำงานของข้อไขในการเขียนโค้ดที่ปลอดภัย และการใช้ async-await ให้เป็นประโยชน์สูงสุดในโปรเจคของคุณ!

หมายเหตุ: ข้อมูลในบทความนี้อาจจะผิด โปรดตรวจสอบความถูกต้องของบทความอีกครั้งหนึ่ง บทความนี้ไม่สามารถนำไปใช้อ้างอิงใด ๆ ได้ ทาง EPT ไม่ขอยืนยันความถูกต้อง และไม่ขอรับผิดชอบต่อความเสียหายใดที่เกิดจากบทความชุดนี้ทั้งทางทรัพย์สิน ร่างกาย หรือจิตใจของผู้อ่านและผู้เกี่ยวข้อง