Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

การนำ async มาประยุกต์ใช้กับการทำงานพร้อมกัน

ในหัวข้อนี้ เราจะนำ async มาจัดการกับโจทย์ความท้าทายด้านการทำงานพร้อมกัน (concurrency) บางส่วนที่เราเคยจัดการด้วยเธรด (thread) ในบทที่ 16 เนื่องจากเราได้พูดถึงแนวคิดสำคัญหลายอย่างไปแล้วในบทนั้น ในหัวข้อนี้เราจึงจะเน้นไปที่สิ่งที่แตกต่างกันระหว่างเธรดกับฟิวเจอร์ (future)

ในหลายกรณี API สำหรับการทำงานพร้อมกันด้วย async จะคล้ายกับ API สำหรับเธรดมาก แต่ในบางกรณีก็แตกต่างกันค่อนข้างมาก และถึงแม้ว่า API ของเธรดกับ async จะดู_คล้ายกัน_ แต่พฤติกรรมการทำงานก็มักจะแตกต่างกัน—รวมถึงแทบทุกครั้งจะมีลักษณะเฉพาะด้านประสิทธิภาพที่ต่างกันด้วย

การสร้างทาสก์ใหม่ด้วย spawn_task

สิ่งแรกที่เราได้ลงมือทำในหัวข้อ“การสร้างเธรดใหม่ด้วย spawn” ในบทที่ 16 คือการนับเลขพร้อมกันบนสองเธรดที่แยกจากกัน เรามาทำแบบเดียวกันนี้โดยใช้ async กัน เครต trpl มีฟังก์ชัน spawn_task ที่มีหน้าตาคล้ายกับ API thread::spawn มาก และมีฟังก์ชัน sleep ซึ่งเป็นเวอร์ชัน async ของ API thread::sleep เราสามารถใช้สองฟังก์ชันนี้ร่วมกันเพื่อสร้างตัวอย่างการนับเลขแบบเดียวกันได้ ดังแสดงในลิสติ้ง 17-6

extern crate trpl; // required for mdbook test

use std::time::Duration;

fn main() {
    trpl::block_on(async {
        trpl::spawn_task(async {
            for i in 1..10 {
                println!("hi number {i} from the first task!");
                trpl::sleep(Duration::from_millis(500)).await;
            }
        });

        for i in 1..5 {
            println!("hi number {i} from the second task!");
            trpl::sleep(Duration::from_millis(500)).await;
        }
    });
}

ในจุดเริ่มต้น เราเตรียมฟังก์ชัน main ด้วย trpl::block_on เพื่อให้ฟังก์ชันระดับบนสุดของเราสามารถเป็น async ได้

หมายเหตุ: ตั้งแต่นี้เป็นต้นไปในบทนี้ ทุกตัวอย่างจะถูกครอบด้วย trpl::block_on ใน main เหมือนกันหมด เราจึงมักจะละเว้นส่วนนี้ไว้เหมือนที่เราละเว้นโครงสร้างของ main ดังนั้นอย่าลืมใส่ลงในโค้ดของคุณด้วย!

จากนั้น เราเขียนลูปสองลูปไว้ข้างในบล็อกดังกล่าว โดยแต่ละลูปจะเรียก trpl::sleep ซึ่งรอเวลาครึ่งวินาที (500 มิลลิวินาที) ก่อนพิมพ์ข้อความถัดไป เรานำลูปหนึ่งไปไว้ในเนื้อของ trpl::spawn_task และนำอีกลูปไปไว้ในลูป for ระดับบนสุด นอกจากนี้เรายังใส่ await ต่อท้ายการเรียก sleep ด้วย

โค้ดนี้ทำงานคล้ายกับการทำงานด้วยเธรด—รวมถึงการที่คุณอาจเห็นข้อความปรากฏในลำดับที่ต่างออกไปในเทอร์มินัลเมื่อรันโปรแกรม:

hi number 1 from the second task!
hi number 1 from the first task!
hi number 2 from the first task!
hi number 2 from the second task!
hi number 3 from the first task!
hi number 3 from the second task!
hi number 4 from the first task!
hi number 4 from the second task!
hi number 5 from the first task!

เวอร์ชันนี้จะหยุดทำงานทันทีที่ลูป for ในเนื้อของบล็อก async หลักทำงานเสร็จ เพราะทาสก์ (task) ที่สร้างขึ้นด้วย spawn_task จะถูกปิดตัวลงเมื่อฟังก์ชัน main สิ้นสุดลง หากคุณต้องการให้มันรันไปจนกระทั่งทาสก์ทั้งหมดทำงานเสร็จ คุณจะต้องใช้ join handle เพื่อรอให้ทาสก์แรกทำงานเสร็จสิ้น สำหรับเธรด เราใช้เมธอด join เพื่อ “บล็อก” จนกว่าเธรดจะทำงานเสร็จ ส่วนในลิสติ้ง 17-7 เราสามารถใช้ await เพื่อทำสิ่งเดียวกันได้ เพราะตัว handle ของทาสก์เองก็เป็นฟิวเจอร์เช่นกัน ชนิด Output ของมันคือ Result เราจึง unwrap มันหลังจากการ await ด้วย

extern crate trpl; // required for mdbook test

use std::time::Duration;

fn main() {
    trpl::block_on(async {
        let handle = trpl::spawn_task(async {
            for i in 1..10 {
                println!("hi number {i} from the first task!");
                trpl::sleep(Duration::from_millis(500)).await;
            }
        });

        for i in 1..5 {
            println!("hi number {i} from the second task!");
            trpl::sleep(Duration::from_millis(500)).await;
        }

        handle.await.unwrap();
    });
}

เวอร์ชันที่อัปเดตนี้จะรันไปจนกว่าลูป_ทั้งสอง_จะทำงานเสร็จสิ้น:

hi number 1 from the second task!
hi number 1 from the first task!
hi number 2 from the first task!
hi number 2 from the second task!
hi number 3 from the first task!
hi number 3 from the second task!
hi number 4 from the first task!
hi number 4 from the second task!
hi number 5 from the first task!
hi number 6 from the first task!
hi number 7 from the first task!
hi number 8 from the first task!
hi number 9 from the first task!

จนถึงตอนนี้ ดูเหมือนว่า async กับเธรดจะให้ผลลัพธ์ที่คล้ายกัน เพียงแต่ใช้วากยสัมพันธ์ต่างกัน: คือใช้ await แทนการเรียก join บน join handle และ await การเรียก sleep

ความแตกต่างที่สำคัญกว่านั้นคือ เราไม่จำเป็นต้องสร้างเธรดของระบบปฏิบัติการขึ้นมาอีกเธรดเพื่อทำงานนี้ ที่จริงแล้ว เราไม่จำเป็นต้องสร้างทาสก์เลยด้วยซ้ำ เพราะบล็อก async จะถูกคอมไพล์เป็นฟิวเจอร์นิรนาม (anonymous future) เราจึงสามารถนำแต่ละลูปไปใส่ไว้ในบล็อก async แล้วให้รันไทม์รันทั้งสองลูปจนเสร็จสมบูรณ์ได้โดยใช้ฟังก์ชัน trpl::join

ในหัวข้อ“การรอให้เธรดทั้งหมดทำงานเสร็จสิ้นด้วย JoinHandle” ในบทที่ 16 เราได้แสดงวิธีใช้เมธอด join บนชนิด JoinHandle ที่ได้จากการเรียก std::thread::spawn ฟังก์ชัน trpl::join ก็คล้ายกันแต่ใช้กับฟิวเจอร์ เมื่อคุณส่งฟิวเจอร์สองตัวเข้าไป มันจะสร้างฟิวเจอร์ใหม่ขึ้นมาหนึ่งตัว ซึ่งเอาต์พุตของมันคือทูเพิลที่บรรจุผลลัพธ์ของฟิวเจอร์แต่ละตัวที่คุณส่งเข้าไป เมื่อฟิวเจอร์_ทั้งสอง_ทำงานเสร็จสิ้นแล้ว ดังนั้นในลิสติ้ง 17-8 เราจึงใช้ trpl::join เพื่อรอให้ทั้ง fut1 และ fut2 ทำงานเสร็จ เราจะ_ไม่_ await fut1 และ fut2 โดยตรง แต่จะ await ฟิวเจอร์ใหม่ที่สร้างขึ้นโดย trpl::join แทน เราละเว้นเอาต์พุตของมันไว้ เพราะเป็นเพียงทูเพิลที่เก็บค่ายูนิตสองค่าเท่านั้น

extern crate trpl; // required for mdbook test

use std::time::Duration;

fn main() {
    trpl::block_on(async {
        let fut1 = async {
            for i in 1..10 {
                println!("hi number {i} from the first task!");
                trpl::sleep(Duration::from_millis(500)).await;
            }
        };

        let fut2 = async {
            for i in 1..5 {
                println!("hi number {i} from the second task!");
                trpl::sleep(Duration::from_millis(500)).await;
            }
        };

        trpl::join(fut1, fut2).await;
    });
}

เมื่อเรารันโค้ดนี้ เราจะเห็นฟิวเจอร์ทั้งสองทำงานจนเสร็จสิ้น:

hi number 1 from the first task!
hi number 1 from the second task!
hi number 2 from the first task!
hi number 2 from the second task!
hi number 3 from the first task!
hi number 3 from the second task!
hi number 4 from the first task!
hi number 4 from the second task!
hi number 5 from the first task!
hi number 6 from the first task!
hi number 7 from the first task!
hi number 8 from the first task!
hi number 9 from the first task!

คราวนี้ คุณจะเห็นลำดับเดิมแบบนี้เป๊ะๆ ทุกครั้ง ซึ่งแตกต่างอย่างมากจากสิ่งที่เราเคยเห็นกับเธรดและกับ trpl::spawn_task ในลิสติ้ง 17-7 นั่นเป็นเพราะฟังก์ชัน trpl::join นั้นมี_ความยุติธรรม_ (fair) หมายความว่ามันจะตรวจสอบฟิวเจอร์แต่ละตัวบ่อยเท่าๆ กัน โดยสลับการทำงานระหว่างกันและไม่ปล่อยให้อีกตัวนำหน้าไปหากอีกตัวก็พร้อมทำงานเช่นกัน สำหรับเธรด ระบบปฏิบัติการจะเป็นผู้ตัดสินใจว่าจะสลับไปตรวจสอบเธรดใดและปล่อยให้รันนานแค่ไหน ส่วน async ใน Rust รันไทม์จะเป็นผู้ตัดสินใจว่าจะตรวจสอบทาสก์ใด (ในทางปฏิบัติ รายละเอียดจะซับซ้อนขึ้นเนื่องจากรันไทม์ของ async อาจใช้เธรดของระบบปฏิบัติการอยู่เบื้องหลังเพื่อช่วยจัดการการทำงานพร้อมกัน การรับประกันความยุติธรรมจึงเป็นภาระงานที่มากขึ้นสำหรับรันไทม์—แต่ก็ยังสามารถทำได้!) รันไทม์ไม่จำเป็นต้องรับประกันความยุติธรรมสำหรับการดำเนินการใดๆ เสมอไป และมักจะมี API หลากหลายให้คุณเลือกได้ว่าจะต้องการความยุติธรรมหรือไม่

ลองปรับเปลี่ยนวิธี await ฟิวเจอร์เหล่านี้ดู แล้วสังเกตผลการทำงาน:

  • ลบบล็อก async ที่ครอบลูปใดลูปหนึ่งหรือทั้งสองลูปออก
  • Await บล็อก async แต่ละตัวทันทีหลังจากที่นิยามมันขึ้นมา
  • ครอบเฉพาะลูปแรกด้วยบล็อก async แล้ว await ฟิวเจอร์ที่ได้หลังจากจบลูปที่สอง

และเพื่อความท้าทายยิ่งขึ้น ลองดูว่าคุณจะสามารถคาดเดาเอาต์พุตในแต่ละกรณีได้หรือไม่_ก่อน_ที่จะรันโค้ดจริง!

การส่งข้อมูลระหว่างสองทาสก์ด้วยการส่งผ่านข้อความ

การแชร์ข้อมูลระหว่างฟิวเจอร์ก็ดูคุ้นเคยเช่นกัน: เราจะใช้การส่งผ่านข้อความ (message passing) อีกครั้ง แต่คราวนี้เป็นชนิดข้อมูลและฟังก์ชันเวอร์ชัน async เราจะใช้วิธีที่ต่างออกไปเล็กน้อยจากที่เราทำในหัวข้อ“ส่งข้อมูลระหว่างเธรดด้วยการส่งผ่านข้อความ” ในบทที่ 16 เพื่อแสดงให้เห็นความแตกต่างสำคัญบางประการระหว่างการทำงานพร้อมกันโดยใช้เธรดกับแบบใช้ฟิวเจอร์ ในลิสติ้ง 17-9 เราจะเริ่มต้นด้วยบล็อก async เพียงบล็อกเดียว—โดย_ไม่ได้_สร้างทาสก์แยกต่างหากเหมือนที่เราเคยสร้างเธรดแยก

extern crate trpl; // required for mdbook test

fn main() {
    trpl::block_on(async {
        let (tx, mut rx) = trpl::channel();

        let val = String::from("hi");
        tx.send(val).unwrap();

        let received = rx.recv().await.unwrap();
        println!("received '{received}'");
    });
}

ในที่นี้ เราใช้ trpl::channel ซึ่งเป็นเวอร์ชัน async ของ API แชนเนล (channel) แบบผู้ผลิตหลายราย ผู้บริโภครายเดียว (multiple producer, single consumer) ที่เราเคยใช้กับเธรดในบทที่ 16 เวอร์ชัน async ของ API นี้แตกต่างจากเวอร์ชันเธรดเพียงเล็กน้อย: คือใช้ตัวรับ rx ที่เปลี่ยนแปลงค่าได้ (mutable) แทนแบบที่เปลี่ยนแปลงไม่ได้ และเมธอด recv ของมันจะให้ผลลัพธ์เป็นฟิวเจอร์ที่เราต้อง await แทนที่จะสร้างค่าโดยตรง ตอนนี้เราสามารถส่งข้อความจากฝั่งผู้ส่งไปยังฝั่งผู้รับได้แล้ว สังเกตว่าเราไม่จำเป็นต้องสร้างเธรดแยกหรือแม้แต่ทาสก์เลย เราเพียงแค่ await การเรียก rx.recv เท่านั้น

เมธอด Receiver::recv แบบซิงโครนัสใน std::mpsc::channel จะบล็อกการทำงานจนกว่าจะได้รับข้อความ แต่เมธอด trpl::Receiver::recv จะไม่บล็อก เพราะมันเป็น async โดยแทนที่จะบล็อก มันจะส่งคืนการควบคุมกลับไปยังรันไทม์จนกว่าจะได้รับข้อความ หรือจนกว่าฝั่งผู้ส่งของแชนเนลจะปิดลง ในทางตรงกันข้าม เราไม่ต้อง await การเรียก send เพราะมันไม่ได้บล็อก และไม่จำเป็นต้องบล็อกเนื่องจากแชนเนลที่เราส่งข้อความเข้าไปนั้นไม่มีการจำกัดขนาด (unbounded)

หมายเหตุ: เนื่องจากโค้ด async ทั้งหมดนี้ทำงานอยู่ในบล็อก async ภายในการเรียก trpl::block_on ทุกอย่างภายในนั้นจึงไม่ต้องบล็อกการทำงาน อย่างไรก็ตาม โค้ดที่อยู่_ภายนอก_บล็อกจะยังคงบล็อกเพื่อรอให้ฟังก์ชัน block_on ทำงานเสร็จและคืนค่ากลับมา นั่นคือจุดประสงค์หลักของฟังก์ชัน trpl::block_on: เพื่อให้คุณสามารถ_เลือก_ได้ว่าจะบล็อกตรงจุดไหนสำหรับชุดโค้ด async และช่วยกำหนดจุดเปลี่ยนผ่านระหว่างโค้ดแบบซิงโครนัสและอะซิงโครนัส

มีสองสิ่งสำคัญที่ควรสังเกตจากตัวอย่างนี้ ข้อแรก ข้อความส่งถึงทันที ข้อสอง แม้ว่าเราจะใช้ฟิวเจอร์ที่นี่ แต่ก็ยังไม่มีการทำงานพร้อมกันเกิดขึ้น ทุกอย่างในลิสติ้งนี้เกิดขึ้นตามลำดับทีละขั้นตอน เช่นเดียวกับตอนที่ไม่ได้ใช้ฟิวเจอร์

เรามาจัดการกับข้อแรกกันก่อน โดยการส่งข้อความหลายข้อความและมีการหน่วงเวลาด้วยการหลับ (sleep) คั่นระหว่างแต่ละข้อความ ดังแสดงในลิสติ้ง 17-10

extern crate trpl; // required for mdbook test

use std::time::Duration;

fn main() {
    trpl::block_on(async {
        let (tx, mut rx) = trpl::channel();

        let vals = vec![
            String::from("hi"),
            String::from("from"),
            String::from("the"),
            String::from("future"),
        ];

        for val in vals {
            tx.send(val).unwrap();
            trpl::sleep(Duration::from_millis(500)).await;
        }

        while let Some(value) = rx.recv().await {
            println!("received '{value}'");
        }
    });
}

นอกจากการส่งข้อความแล้ว เรายังต้องรับข้อความด้วย ในกรณีนี้ เนื่องจากเรารู้อยู่แล้วว่าจะมีข้อความเข้ามาทั้งหมดกี่ข้อความ เราจึงทำด้วยตนเองได้โดยเรียก rx.recv().await สี่ครั้ง อย่างไรก็ตาม ในโลกจริง เรามักจะไม่รู้จำนวนข้อความที่แน่นอนล่วงหน้า ดังนั้นเราจึงต้องรอต่อไปจนกว่าจะแน่ใจว่าไม่มีข้อความเหลืออยู่อีกแล้ว

ในลิสติ้ง 16-10 เราใช้ลูป for เพื่อประมวลผลสมาชิกทั้งหมดที่รับมาจากแชนเนลแบบซิงโครนัส อย่างไรก็ตาม Rust ยังไม่มีวิธีใช้ลูป for กับลำดับสมาชิกที่_ถูกสร้างขึ้นแบบอะซิงโครนัส_ เราจึงจำเป็นต้องใช้ลูปแบบมีเงื่อนไข while let ซึ่งเป็นเวอร์ชันลูปของโครงสร้าง if let ที่เราเคยเห็นในหัวข้อ“การควบคุมโฟลว์แบบกระชับด้วย if let และ let...else” ในบทที่ 6 ลูปนี้จะทำงานต่อไปตราบเท่าที่แพตเทิร์นที่กำหนดไว้ยังคงแมตช์กับค่าอยู่

การเรียก rx.recv จะให้ผลลัพธ์เป็นฟิวเจอร์ ซึ่งเรา await รันไทม์จะหยุดพักฟิวเจอร์ไว้ชั่วคราวจนกว่ามันจะพร้อม เมื่อมีข้อความมาถึง ฟิวเจอร์จะคลี่คลาย (resolve) เป็น Some(message) ทุกครั้งที่มีข้อความเข้ามา และเมื่อแชนเนลปิด ไม่ว่าจะมีข้อความมาถึง_หรือไม่_ก็ตาม ฟิวเจอร์จะคลี่คลายเป็น None แทน เพื่อบ่งบอกว่าไม่มีค่าใดๆ เหลืออยู่อีกแล้ว และเราควรหยุดการโพลล์ (polling)—นั่นคือ หยุดการ await

ลูป while let รวบรวมทั้งหมดนี้เข้าด้วยกัน หากผลลัพธ์ของการเรียก rx.recv().await คือ Some(message) เราจะเข้าถึงข้อความได้และนำไปใช้ในบอดี้ของลูปได้ เช่นเดียวกับที่เราทำได้กับ if let หากผลลัพธ์เป็น None ลูปก็จะสิ้นสุดลง ทุกครั้งที่ลูปทำงานครบรอบ มันจะแตะจุด await อีกครั้ง ทำให้รันไทม์หยุดพักมันชั่วคราวอีกรอบจนกว่าข้อความใหม่จะมาถึง

ตอนนี้โค้ดส่งและรับข้อความทั้งหมดได้สำเร็จแล้ว แต่น่าเสียดายที่ยังมีปัญหาอยู่สองประการ อย่างแรก ข้อความไม่ได้ทยอยเข้ามาทีละช่วงครึ่งวินาที แต่กลับมาถึงพร้อมกันทั้งหมดในคราวเดียวหลังจากโปรแกรมเริ่มทำงานไปแล้ว 2 วินาที (2,000 มิลลิวินาที) อย่างที่สอง โปรแกรมนี้ก็ไม่ยอมออกจากโปรแกรมเหมือนกัน! มันกลับรอรับข้อความใหม่ไปตลอดกาล คุณจะต้องปิดมันด้วยปุ่ม ctrl-C

โค้ดภายในบล็อก async หนึ่งบล็อกทำงานเป็นเส้นตรง

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

ในลิสติ้ง 17-10 มีบล็อก async เพียงบล็อกเดียว ทุกอย่างในนั้นจึงทำงานเป็นเส้นตรง (linearly) ซึ่งยังไม่มีการทำงานพร้อมกันเกิดขึ้น การเรียก tx.send ทั้งหมดจะเกิดขึ้นสลับกับการเรียก trpl::sleep และจุด await ที่เกี่ยวข้องคั่นอยู่ตลอด จากนั้นลูป while let ถึงจะได้เริ่มผ่านจุด await ใดๆ บนการเรียก recv

เพื่อให้ได้พฤติกรรมที่เราต้องการ ซึ่งก็คือมีความหน่วงจากการหลับคั่นระหว่างแต่ละข้อความ เราต้องวางการดำเนินการของ tx และ rx ไว้ในบล็อก async ของตัวเอง ดังแสดงในลิสติ้ง 17-11 จากนั้นรันไทม์จึงจะเรียกใช้แต่ละบล็อกแยกกันได้โดยใช้ trpl::join เช่นเดียวกับในลิสติ้ง 17-8 และอีกครั้งที่เราจะ await ผลลัพธ์ของการเรียก trpl::join ไม่ใช่ await ฟิวเจอร์แต่ละตัว หากเรา await ฟิวเจอร์แต่ละตัวตามลำดับ เราก็จะกลับไปสู่โฟลว์การทำงานแบบเรียงตามลำดับเหมือนเดิม—ซึ่งเป็นสิ่งที่เราพยายาม_ไม่_ทำอย่างยิ่ง

extern crate trpl; // required for mdbook test

use std::time::Duration;

fn main() {
    trpl::block_on(async {
        let (tx, mut rx) = trpl::channel();

        let tx_fut = async {
            let vals = vec![
                String::from("hi"),
                String::from("from"),
                String::from("the"),
                String::from("future"),
            ];

            for val in vals {
                tx.send(val).unwrap();
                trpl::sleep(Duration::from_millis(500)).await;
            }
        };

        let rx_fut = async {
            while let Some(value) = rx.recv().await {
                println!("received '{value}'");
            }
        };

        trpl::join(tx_fut, rx_fut).await;
    });
}

ด้วยโค้ดที่อัปเดตในลิสติ้ง 17-11 ข้อความจะถูกพิมพ์ออกมาเป็นช่วงๆ ทุก 500 มิลลิวินาที แทนที่จะพิมพ์รวดเดียวทั้งหมดหลังจากผ่านไป 2 วินาที

การย้ายความเป็นเจ้าของเข้าสู่บล็อก async

อย่างไรก็ตาม โปรแกรมยังคงไม่ยอมออกจากการทำงาน เนื่องจากวิธีที่ลูป while let โต้ตอบกับ trpl::join:

  • ฟิวเจอร์ที่คืนค่าจาก trpl::join จะเสร็จสมบูรณ์ก็ต่อเมื่อฟิวเจอร์_ทั้งสอง_ที่ส่งเข้าไปทำงานเสร็จสิ้นแล้วเท่านั้น
  • ฟิวเจอร์ tx_fut เสร็จสิ้นเมื่อมันหลับเสร็จหลังส่งข้อความสุดท้ายใน vals เรียบร้อยแล้ว
  • ฟิวเจอร์ rx_fut จะไม่เสร็จสิ้นจนกว่าลูป while let จะสิ้นสุดลง
  • ลูป while let จะไม่สิ้นสุดลงจนกว่าการ await rx.recv จะให้ผลลัพธ์เป็น None
  • การ await rx.recv จะคืนค่า None ก็ต่อเมื่อปลายทางอีกฝั่งของแชนเนลปิดลงแล้วเท่านั้น
  • แชนเนลจะปิดลงก็ต่อเมื่อเราเรียก rx.close หรือเมื่อฝั่งผู้ส่ง tx ถูกทิ้ง (drop)
  • เราไม่ได้เรียก rx.close ที่ใดเลย และ tx จะไม่ถูกทิ้งจนกว่าบล็อก async ชั้นนอกสุดที่ส่งให้ trpl::block_on จะสิ้นสุดลง
  • บล็อกนั้นสิ้นสุดไม่ได้เพราะมันถูกบล็อกรอให้ trpl::join เสร็จสิ้น ซึ่งพาเราวนกลับไปยังต้นรายการนี้

ในตอนนี้ บล็อก async ที่เราใช้ส่งข้อความนั้นเพียงแค่_ยืม_ tx เท่านั้น เพราะการส่งข้อความไม่ต้องใช้ความเป็นเจ้าของ แต่หากเราสามารถ_ย้าย_ (move) tx เข้าไปในบล็อก async นั้นได้ มันก็จะถูกทิ้งเมื่อบล็อกนั้นสิ้นสุดลง ในหัวข้อ“การจับเรเฟอเรนซ์หรือการย้ายความเป็นเจ้าของ” ในบทที่ 13 คุณได้เรียนรู้วิธีใช้คีย์เวิร์ด move กับโคลเชอร์ไปแล้ว และดังที่อภิปรายในหัวข้อ“การใช้โคลเชอร์ move กับเธรด” ในบทที่ 16 เรามักต้องย้ายข้อมูลเข้าไปในโคลเชอร์เมื่อทำงานกับเธรด กลไกพื้นฐานเดียวกันนี้ก็นำมาใช้กับบล็อก async ด้วย ดังนั้นคีย์เวิร์ด move จึงทำงานกับบล็อก async ได้เช่นเดียวกับที่มันทำกับโคลเชอร์

ในลิสติ้ง 17-12 เราเปลี่ยนบล็อกที่ใช้ส่งข้อความจาก async เป็น async move

extern crate trpl; // required for mdbook test

use std::time::Duration;

fn main() {
    trpl::block_on(async {
        let (tx, mut rx) = trpl::channel();

        let tx_fut = async move {
            // --snip--
            let vals = vec![
                String::from("hi"),
                String::from("from"),
                String::from("the"),
                String::from("future"),
            ];

            for val in vals {
                tx.send(val).unwrap();
                trpl::sleep(Duration::from_millis(500)).await;
            }
        };

        let rx_fut = async {
            while let Some(value) = rx.recv().await {
                println!("received '{value}'");
            }
        };

        trpl::join(tx_fut, rx_fut).await;
    });
}

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

การ join ฟิวเจอร์หลายตัวด้วยมาโคร join!

แชนเนล async นี้ยังเป็นแชนเนลแบบผู้ผลิตหลายรายด้วยเช่นกัน เราจึงเรียก clone บน tx ได้หากต้องการส่งข้อความจากฟิวเจอร์หลายตัว ดังแสดงในลิสติ้ง 17-13

extern crate trpl; // required for mdbook test

use std::time::Duration;

fn main() {
    trpl::block_on(async {
        let (tx, mut rx) = trpl::channel();

        let tx1 = tx.clone();
        let tx1_fut = async move {
            let vals = vec![
                String::from("hi"),
                String::from("from"),
                String::from("the"),
                String::from("future"),
            ];

            for val in vals {
                tx1.send(val).unwrap();
                trpl::sleep(Duration::from_millis(500)).await;
            }
        };

        let rx_fut = async {
            while let Some(value) = rx.recv().await {
                println!("received '{value}'");
            }
        };

        let tx_fut = async move {
            let vals = vec![
                String::from("more"),
                String::from("messages"),
                String::from("for"),
                String::from("you"),
            ];

            for val in vals {
                tx.send(val).unwrap();
                trpl::sleep(Duration::from_millis(1500)).await;
            }
        };

        trpl::join!(tx1_fut, tx_fut, rx_fut);
    });
}

อันดับแรก เราโคลน tx เพื่อสร้าง tx1 ไว้นอกบล็อก async แรก เราย้าย tx1 เข้าไปในบล็อกนั้นเหมือนที่เราทำกับ tx ก่อนหน้านี้ จากนั้นเราย้าย tx ตัวเดิมเข้าไปในบล็อก async ใหม่ ซึ่งเราจะส่งข้อความเพิ่มเติมโดยมีความหน่วงที่ช้าลงเล็กน้อย ในที่นี้เราวางบล็อก async ใหม่นี้ไว้หลังบล็อก async สำหรับรับข้อความ แต่มันจะวางไว้ก่อนหน้าก็ให้ผลลัพธ์เหมือนกัน หัวใจสำคัญอยู่ที่ลำดับที่ฟิวเจอร์ถูก await ไม่ใช่ลำดับที่พวกมันถูกสร้างขึ้นมา

บล็อก async ทั้งสองสำหรับการส่งข้อความจำเป็นต้องเป็นบล็อก async move เพื่อให้ทั้ง tx และ tx1 ถูกทิ้งเมื่อบล็อกเหล่านั้นทำงานเสร็จ มิฉะนั้น เราจะกลับไปติดอยู่ในลูปอนันต์เดิมที่เราเริ่มต้น

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

ตอนนี้เราจะเห็นข้อความทั้งหมดจากฟิวเจอร์ฝั่งส่งทั้งสองตัว และเนื่องจากฟิวเจอร์ฝั่งส่งใช้ความหน่วงที่ต่างกันเล็กน้อยหลังการส่ง ข้อความจึงถูกรับในช่วงเวลาที่ต่างกันเหล่านั้นด้วย:

received 'hi'
received 'more'
received 'from'
received 'the'
received 'messages'
received 'future'
received 'for'
received 'you'

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