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

การทำงานพร้อมกันหรือ "Concurrency" เป็นหัวใจสำคัญของการเขียนโปรแกรมสมัยใหม่ ภาษารัสต์ (Rust) ได้ถูกออกแบบมาให้รองรับการทำงานแบบพร้อมกัน (concurrency) อย่างปลอดภัยโดยใช้คุณสมบัติของการจัดการความทรงจำสไตล์ RAII (Resource Acquisition Is Initialization) และ ownership ซึ่งทำให้โอกาสเกิด data races ลดลงอย่างมาก เราจะมาดูกันว่าเราจะสามารถใช้งาน thread ในภาษารัสต์ได้อย่างไร พร้อมกับตัวอย่างโค้ดและการประยุกต์ใช้งานในโลกจริงนั่นเอง

ตัวอย่างที่ 1: การสร้าง Thread

 use std::thread;

fn main() {
    thread::spawn(|| {
        // งานที่จะทำใน thread ใหม่
        for i in 1..10 {
            println!("นับเลข {}", i);
            thread::sleep(std::time::Duration::from_millis(1000));
        }
    });

    // งานใน main thread
    for i in 1..5 {
        println!("นับเลขจาก main thread {}", i);
        thread::sleep(std::time::Duration::from_millis(500));
    }
}

ในตัวอย่างนี้ เราได้สร้าง thread ใหม่ขึ้นมาหนึ่ง thread โดยใช้ `thread::spawn` และใช้การหลับ (sleep) ระหว่างการนับเลข สังเกตว่า main thread และ thread ใหม่ทำงานพร้อมกัน

ตัวอย่างที่ 2: การจัดการกับ Thread ผ่านการใช้งาน JoinHandle

 use std::thread;

fn main() {
    let child = thread::spawn(|| {
        // งานที่จะทำใน thread ใหม่
        for i in 1..10 {
            println!("นับเลข {}", i);
            thread::sleep(std::time::Duration::from_millis(1000));
        }
    });

    // งานใน main thread
    for i in 1..5 {
        println!("นับเลขจาก main thread {}", i);
        thread::sleep(std::time::Duration::from_millis(500));
    }

    child.join().unwrap(); // รอจนกว่า thread ที่สร้างขึ้นมาจะทำงานเสร็จ
}

คราวนี้เราจะรอการทำงานของ thread ด้วยการใช้ `child.join()` ซึ่งจะทำให้ main thread รอจนกว่า thread ที่เราสร้างขึ้นมานั้นทำงานเสร็จสิ้น

ตัวอย่างที่ 3: การใช้งานข้ามข้อมูลระหว่าง Threadsโดยใช้ Arc และ Mutex

 use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("จำนวนทั้งหมด: {}", *counter.lock().unwrap());
}

กรณีนี้เป็นการแชร์ตัวแปรระหว่าง threads หลาย ๆ ตัว โดยการใช้ `Arc` (Atomic Reference Counted) จับคู่กับ `Mutex` (Mutual Exclusion) เพื่อจัดการการเข้าถึงข้อมูลอย่างปลอดภัย

Usecase ในโลกจริง

การใช้งาน thread อย่างมีประสิทธิภาพสามารถช่วยปรับปรุงการทำงานของโปรแกรมในหลายสถานการณ์ เช่นการประมวลผลข้อมูลขนาดใหญ่โดยแบ่งออกเป็นส่วนย่อยๆ เพื่อทำงานพร้อมกัน, การสร้างเว็บเซิร์ฟเวอร์ที่สามารถรองรับการติดต่อสื่อสารจากลูกค้าหลายๆ เซสชันในเวลาเดียวกัน โดยไม่ให้ขัดข้อง หรือแม้แต่การพัฒนาเกมที่ต้องการการประมวลผลหลายอย่างพร้อมๆ กัน

การเรียนรู้เกี่ยวกับการใช้งาน thread ในภาษารัสต์จะช่วยเพิ่มขีดความสามารถของนักพัฒนาโปรแกรมในการเขียนโค้ดสำหรับโปรแกรมที่มีประสิทธิภาพสูงและปลอดภัย หากคุณสนใจที่จะพัฒนาทักษะการเขียนโปรแกรมโดยใช้ภาษารัสต์และสำรวจความลึกของการจัดการ thread อย่าลังเลที่จะติดต่อ EPT ซึ่งเป็นหนึ่งในโรงเรียนสอนเขียนโปรแกรมที่จะช่วยให้คุณไปถึงระดับถัดไปในการเขียนโค้ดอย่างมืออาชีพ

การเรียนรู้และความเข้าใจเกี่ยวกับ concurrency ในภาษารัสต์จะเป็นพื้นฐานสำคัญให้กับนักพัฒนาที่ต้องการก้าวไปข้างหน้าในยุคดิจิทัล และ EPT ยินดีที่จะเป็นส่วนหนึ่งของการเติบโตในอาชีพของคุณ!

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