ส่งข้อมูลระหว่างเธรดด้วยการส่งผ่านข้อความ
แนวทางหนึ่งที่ได้รับความนิยมเพิ่มขึ้นเรื่อยๆ ในการรับประกันความปลอดภัยของการทำงานพร้อมกัน (concurrency) คือการส่งผ่านข้อความ (message passing) โดยที่เธรด (threads) หรือแอกเตอร์ (actors) จะสื่อสารกันโดยการส่งข้อความที่มีข้อมูลบรรจุอยู่ให้แก่กันและกัน แนวคิดนี้สรุปไว้เป็นสโลแกนในเอกสารภาษา Go ว่า: “อย่าสื่อสารกันด้วยการแชร์หน่วยความจำ แต่จงแชร์หน่วยความจำด้วยการสื่อสารกัน”
เพื่อให้สามารถทำงานพร้อมกันแบบส่งผ่านข้อความได้ ไลบรารีมาตรฐานของ Rust จึงได้เตรียมการอิมพลีเมนต์แชนเนล (channels) ไว้ โดย_แชนเนล_ถือเป็นแนวคิดทั่วไปในการเขียนโปรแกรมที่ใช้สำหรับส่งข้อมูลจากเธรดหนึ่งไปยังอีกเธรดหนึ่ง
คุณสามารถจินตนาการถึงแชนเนลในการเขียนโปรแกรมว่าเปรียบเสมือนลำน้ำที่มีทิศทางการไหล เช่น ลำธารหรือแม่น้ำ หากคุณปล่อยวัตถุอย่างเป็ดยางลงไปในแม่น้ำ มันก็จะลอยตามน้ำไปจนถึงปลายน้ำ
แชนเนลประกอบด้วยสองส่วนหลักคือ: ฝั่งส่ง (transmitter) และฝั่งรับ (receiver) ฝั่งส่งคือตำแหน่งต้นน้ำที่คุณปล่อยเป็ดยางลงน้ำ และฝั่งรับคือตำแหน่งปลายน้ำที่เป็ดยางลอยไปถึง โค้ดส่วนหนึ่งของคุณจะเรียกเมธอดบนฝั่งส่งพร้อมส่งข้อมูลที่ต้องการส่งออกไป และอีกส่วนหนึ่งจะคอยตรวจสอบฝั่งรับว่ามีข้อความส่งมาถึงหรือไม่ แชนเนลจะถือว่า_ปิดตัวลง_ (closed) หากฝั่งส่งหรือฝั่งรับฝั่งใดฝั่งหนึ่งถูกทิ้ง (dropped) หรือทำลายไป
ในที่นี้ เราจะค่อยๆ พัฒนาโปรแกรมที่มีเธรดหนึ่งคอยสร้างค่าและส่งค่าเหล่านั้นผ่านแชนเนล และอีกเธรดหนึ่งคอยรับค่าเพื่อนำมาพิมพ์แสดงผล เราจะส่งค่าง่ายๆ ระหว่างเธรดโดยใช้แชนเนลเพื่อแสดงให้เห็นการทำงานของฟีเจอร์นี้ เมื่อคุณเข้าใจและคุ้นเคยกับเทคนิคนี้แล้ว คุณสามารถนำแชนเนลไปประยุกต์ใช้กับเธรดใดๆ ที่จำเป็นต้องสื่อสารกัน เช่น ระบบแชต หรือระบบที่หลายๆ เธรดช่วยกันคำนวณงานย่อยแล้วส่งผลลัพธ์มารวมกันที่เธรดเดียว
ก่อนอื่น ในลิสติ้ง 16-6 เราจะเริ่มจากการสร้างแชนเนลขึ้นมาก่อนแต่ยังไม่ทำอะไรกับมัน โปรดทราบว่าโค้ดนี้จะยังไม่สามารถคอมไพล์ผ่านได้ เพราะ Rust ไม่สามารถอนุมานได้ว่าเราต้องการส่งค่าชนิดข้อมูลใดผ่านแชนเนล
use std::sync::mpsc;
fn main() {
let (tx, rx) = mpsc::channel();
}
เราสร้างแชนเนลใหม่โดยใช้ฟังก์ชัน mpsc::channel โดยที่คำว่า mpsc ย่อมาจาก ผู้ผลิตหลายราย ผู้บริโภครายเดียว (multiple producer, single consumer) สรุปง่ายๆ ก็คือ วิธีที่ไลบรารีมาตรฐานของ Rust อิมพลีเมนต์แชนเนลนั้นอนุญาตให้แชนเนลมีฝั่งส่ง (sending ends) ที่คอยผลิตค่าได้หลายตัว แต่สามารถมีฝั่งรับ (receiving end) ที่คอยนำค่านั้นไปใช้งานได้เพียงตัวเดียวเท่านั้น ลองนึกภาพลำธารหลายสายที่ไหลมารวมกันเป็นแม่น้ำใหญ่สายเดียว: สิ่งใดก็ตามที่ถูกปล่อยลงในลำธารสายใดสายหนึ่ง สุดท้ายก็จะลอยมารวมอยู่ที่แม่น้ำสายเดียวกันในที่สุด ตอนนี้เราจะเริ่มต้นด้วยผู้ผลิตเพียงรายเดียวก่อน แล้วค่อยเพิ่มผู้ผลิตหลายรายเมื่อตัวอย่างนี้ทำงานได้เรียบร้อยแล้ว
ฟังก์ชัน mpsc::channel จะคืนค่ากลับมาเป็นทูเพิล (tuple) โดยสมาชิกตัวแรกคือฝั่งส่ง—ตัวส่ง (transmitter)—และสมาชิกตัวที่สองคือฝั่งรับ—ตัวรับ (receiver) ตัวย่อ tx และ rx เป็นคำที่นิยมใช้กันตามธรรมเนียมในหลายวงการสำหรับแทน_ตัวส่ง_ (transmitter) และ_ตัวรับ_ (receiver) ตามลำดับ เราจึงตั้งชื่อตัวแปรตามนั้นเพื่อระบุถึงแต่ละฝั่ง เราใช้คำสั่ง let ร่วมกับแพตเทิร์นเพื่อแจกแจงโครงสร้าง (destructuring) สมาชิกของทูเพิลออกมา ซึ่งเราจะได้เรียนรู้การใช้แพตเทิร์นและ destructuring ในคำสั่ง let เพิ่มเติมในบทที่ 19 สำหรับตอนนี้ ขอให้เข้าใจว่าการใช้คำสั่ง let ในลักษณะนี้เป็นวิธีที่สะดวกในการดึงชิ้นส่วนต่างๆ ของทูเพิลที่ mpsc::channel คืนกลับมา
คราวนี้เรามาย้ายฝั่งส่งเข้าไปไว้ในเธรดที่ถูกสร้างขึ้นและสั่งให้มันส่งข้อความสตริงข้อความหนึ่ง เพื่อให้เธรดที่ถูกสร้างสื่อสารกับเธรดหลักได้ ดังแสดงในลิสติ้ง 16-7 ซึ่งเปรียบเหมือนการใส่เป็ดยางลงในแม่น้ำทางต้นน้ำ หรือการส่งข้อความแชตจากเธรดหนึ่งไปยังอีกเธรดหนึ่ง
use std::sync::mpsc;
use std::thread;
fn main() {
let (tx, rx) = mpsc::channel();
thread::spawn(move || {
let val = String::from("hi");
tx.send(val).unwrap();
});
}
เช่นเคย เราใช้ thread::spawn เพื่อสร้างเธรดใหม่ จากนั้นใช้คำสงวน move เพื่อย้าย tx เข้าไปในโคลเชอร์ (closure) ทำให้เธรดใหม่ได้รับสิทธิ์ความเป็นเจ้าของใน tx ซึ่งเธรดใหม่จำเป็นต้องเป็นเจ้าของตัวส่งนี้เพื่อจะสามารถส่งข้อความผ่านแชนเนลได้
ตัวส่งมีเมธอด send ที่รับค่าที่เราต้องการส่งเข้ามา โดยเมธอด send จะส่งคืนค่าเป็นชนิด Result<T, E> ดังนั้นหากฝั่งตัวรับถูกทิ้ง (drop) ไปแล้วและไม่มีผู้ใดคอยรอรับค่าอีกต่อไป การดำเนินการส่งข้อความก็จะส่งคืนค่าเป็นข้อผิดพลาดออกมา ในตัวอย่างนี้ เราเรียก unwrap เพื่อให้เกิดการแพนิก (panic) หากมีข้อผิดพลาดเกิดขึ้น แต่ในแอปพลิเคชันจริง เราควรจัดการข้อผิดพลาดอย่างเหมาะสม ซึ่งคุณสามารถทบทวนกลยุทธ์การจัดการข้อผิดพลาดได้จากบทที่ 9
ในลิสติ้ง 16-8 เราจะรับค่าจากตัวรับในเธรดหลัก ซึ่งเปรียบเหมือนการเก็บเป็ดยางขึ้นมาจากน้ำที่ปลายแม่น้ำ หรือการรับข้อความแชต
use std::sync::mpsc;
use std::thread;
fn main() {
let (tx, rx) = mpsc::channel();
thread::spawn(move || {
let val = String::from("hi");
tx.send(val).unwrap();
});
let received = rx.recv().unwrap();
println!("Got: {received}");
}
ฝั่งตัวรับมีเมธอดที่มีประโยชน์สองตัว ได้แก่: recv และ try_recv ในที่นี้เราเลือกใช้ recv ซึ่งย่อมาจาก receive โดยเมธอดนี้จะบล็อก (block) การทำงานของเธรดหลักไว้เพื่อรอจนกว่าจะมีค่าถูกส่งมาตามแชนเนล และเมื่อมีค่าส่งมาถึง recv จะส่งคืนค่านั้นออกมาในห่อ Result<T, E> และเมื่อฝั่งตัวส่งปิดตัวลง (closed) เมธอด recv ก็จะส่งคืนข้อผิดพลาดออกมาเพื่อส่งสัญญาณแจ้งว่า จะไม่มีข้อมูลใดๆ ถูกส่งมาอีกแล้ว
ส่วนเมธอด try_recv จะไม่บล็อกการทำงานของเธรด แต่จะส่งคืนค่าเป็น Result<T, E> ออกมาทันที: หากมีข้อความรออยู่ ก็จะส่งคืนค่า Ok ที่บรรจุข้อความนั้นออกมา และจะส่งคืนค่า Err หากในขณะนั้นยังไม่มีข้อความใดๆ ส่งมาถึงเลย การใช้ try_recv มีประโยชน์อย่างยิ่งหากเธรดนั้นมีงานอื่นที่ต้องทำระหว่างรอข้อความ เช่น เราอาจเขียนลูปที่คอยเรียก try_recv เป็นระยะๆ เพื่อประมวลผลข้อความหากมีเข้ามา และหากยังไม่มี ก็สามารถสลับไปทำงานอื่นก่อนได้แล้วค่อยวนกลับมาตรวจสอบใหม่
ในตัวอย่างนี้เราเลือกใช้ recv เพื่อความเรียบง่าย เนื่องจากเธรดหลักไม่มีงานอื่นที่ต้องทำนอกจากการรอข้อความ การสั่งบล็อกเธรดหลักไว้จึงเป็นแนวทางที่เหมาะสม
เมื่อเรารันโค้ดในลิสติ้ง 16-8 เราจะเห็นค่าที่ถูกพิมพ์ออกมาจากเธรดหลัก:
Got: hi
ยอดเยี่ยมมาก!
การถ่ายโอนความเป็นเจ้าของผ่านแชนเนล
กฎความเป็นเจ้าของมีบทบาทสำคัญอย่างยิ่งต่อการส่งข้อความ เพราะมันช่วยรับประกันว่าโค้ดที่ทำงานพร้อมกันจะปลอดภัยเสมอ การป้องกันข้อผิดพลาดในการทำงานพร้อมกันถือเป็นข้อได้เปรียบสำคัญของการนำระบบความเป็นเจ้าของมาใช้ทั่วทั้งโปรแกรม Rust มาลองทำการทดลองเพื่อดูว่าแชนเนลและระบบความเป็นเจ้าของทำงานประสานกันอย่างไรในการป้องกันปัญหา: เราจะลองเรียกใช้ค่า val ในเธรดใหม่_หลังจาก_ที่ได้ส่งค่านั้นผ่านแชนเนลไปแล้ว ลองคอมไพล์โค้ดในลิสติ้ง 16-9 เพื่อดูว่าทำไม Rust จึงไม่อนุญาตให้ทำเช่นนั้น
use std::sync::mpsc;
use std::thread;
fn main() {
let (tx, rx) = mpsc::channel();
thread::spawn(move || {
let val = String::from("hi");
tx.send(val).unwrap();
println!("val is {val}");
});
let received = rx.recv().unwrap();
println!("Got: {received}");
}
ในตัวอย่างนี้ เราพยายามพิมพ์ค่า val ออกมาหลังจากที่ได้ส่งมันผ่านแชนเนลไปด้วย tx.send ไปแล้ว การยินยอมให้ทำเช่นนี้ย่อมเป็นอันตรายอย่างยิ่ง: เพราะเมื่อค่านั้นถูกส่งไปยังอีกเธรดหนึ่งแล้ว เธรดปลายทางอาจแก้ไขหรือทิ้งค่านั้นไปก่อนที่เราจะเรียกใช้มันซ้ำ การที่เธรดอื่นแอบแก้ไขข้อมูลอาจทำให้เกิดข้อผิดพลาดร้ายแรงหรือได้ผลลัพธ์ที่ผิดเพี้ยนไป เนื่องจากข้อมูลอาจไม่สอดคล้องกันหรือไม่คงอยู่อีกต่อไปแล้ว ทว่า Rust จะแจ้งข้อผิดพลาดทันทีตั้งแต่ตอนคอมไพล์โค้ดในลิสติ้ง 16-9:
$ cargo run
Compiling message-passing v0.1.0 (file:///projects/message-passing)
error[E0382]: borrow of moved value: `val`
--> src/main.rs:10:27
|
8 | let val = String::from("hi");
| --- move occurs because `val` has type `String`, which does not implement the `Copy` trait
9 | tx.send(val).unwrap();
| --- value moved here
10 | println!("val is {val}");
| ^^^ value borrowed here after move
For more information about this error, try `rustc --explain E0382`.
error: could not compile `message-passing` (bin "message-passing") due to 1 previous error
ความผิดพลาดในการเขียนโปรแกรมแบบทำงานพร้อมกันของเราถูกตรวจจับได้ตั้งแต่ขั้นตอนการคอมไพล์! ฟังก์ชัน send จะรับสิทธิ์ความเป็นเจ้าของในพารามิเตอร์ของมัน และเมื่อค่านั้นถูกย้าย (move) ฝั่งตัวรับก็จะกลายเป็นเจ้าของใหม่ของค่านั้นทันที กลไกนี้ช่วยป้องกันไม่ให้เราเผลอนำค่านั้นกลับมาใช้งานซ้ำหลังจากส่งมันออกไปแล้ว ระบบความเป็นเจ้าของจึงทำหน้าที่เป็นเกราะป้องกันข้อผิดพลาดได้อย่างสมบูรณ์แบบ
การส่งหลายค่า
โค้ดในลิสติ้ง 16-8 สามารถคอมไพล์และรันได้ก็จริง แต่มันยังไม่ได้แสดงให้เราเห็นอย่างชัดเจนว่า เธรดทั้งสองตัวกำลังทำงานและสื่อสารกันไปพร้อมๆ กันจริงหรือไม่
ในลิสติ้ง 16-10 เราจึงปรับปรุงโค้ดเพื่อพิสูจน์ให้เห็นว่าโค้ดกำลังทำงานแบบพร้อมกันจริงๆ: คราวนี้เธรดใหม่จะส่งข้อความหลายข้อความ โดยหยุดพักเป็นเวลาหนึ่งวินาทีระหว่างการส่งแต่ละข้อความ
use std::sync::mpsc;
use std::thread;
use std::time::Duration;
fn main() {
let (tx, rx) = mpsc::channel();
thread::spawn(move || {
let vals = vec![
String::from("hi"),
String::from("from"),
String::from("the"),
String::from("thread"),
];
for val in vals {
tx.send(val).unwrap();
thread::sleep(Duration::from_secs(1));
}
});
for received in rx {
println!("Got: {received}");
}
}
ในครั้งนี้ เธรดใหม่จะมีเวกเตอร์ของสตริงที่ต้องการส่งไปยังเธรดหลัก เราวนซ้ำส่งข้อความทีละตัว และหยุดพักระหว่างแต่ละข้อความโดยเรียกฟังก์ชัน thread::sleep กำหนดช่วงเวลา Duration เป็นหนึ่งวินาที
ส่วนในเธรดหลัก เราไม่ได้เรียกฟังก์ชัน recv ด้วยตนเองอีกต่อไป: แต่เราสามารถมอง rx ให้ทำหน้าที่เป็นอิเทอเรเตอร์ (iterator) ได้โดยตรง โดยในแต่ละรอบของการวนซ้ำ เราจะพิมพ์ค่าที่ได้รับออกมา และเมื่อแชนเนลถูกปิดตัวลง การวนซ้ำของลูปก็จะสิ้นสุดลงโดยอัตโนมัติ
เมื่อรันโค้ดในลิสติ้ง 16-10 คุณควรเห็นเอาต์พุตต่อไปนี้โดยมีช่วงหยุดพักหนึ่งวินาทีระหว่างแต่ละบรรทัด:
Got: hi
Got: from
Got: the
Got: thread
เนื่องจากเราไม่ได้ใส่โค้ดหน่วงเวลาใดๆ ไว้ในลูป for ของเธรดหลักเลย เราจึงเห็นได้อย่างชัดเจนว่า เธรดหลักกำลังหยุดรอรับค่าที่ทยอยส่งมาจากเธรดใหม่อยู่จริงๆ
การสร้างผู้ผลิตหลายราย
ก่อนหน้านี้เราได้กล่าวไว้ว่า mpsc ย่อมาจาก ผู้ผลิตหลายราย ผู้บริโภครายเดียว (multiple producer, single consumer) ตอนนี้เรามาใช้ประโยชน์จากความสามารถนี้ ด้วยการขยายโค้ดในลิสติ้ง 16-10 เพื่อสร้างหลายๆ เธรดที่ต่างส่งข้อความเข้ามายังตัวรับตัวเดียวกัน เราสามารถทำได้โดยการโคลน (clone) ฝั่งตัวส่ง ดังแสดงในลิสติ้ง 16-11
use std::sync::mpsc;
use std::thread;
use std::time::Duration;
fn main() {
// --snip--
let (tx, rx) = mpsc::channel();
let tx1 = tx.clone();
thread::spawn(move || {
let vals = vec![
String::from("hi"),
String::from("from"),
String::from("the"),
String::from("thread"),
];
for val in vals {
tx1.send(val).unwrap();
thread::sleep(Duration::from_secs(1));
}
});
thread::spawn(move || {
let vals = vec![
String::from("more"),
String::from("messages"),
String::from("for"),
String::from("you"),
];
for val in vals {
tx.send(val).unwrap();
thread::sleep(Duration::from_secs(1));
}
});
for received in rx {
println!("Got: {received}");
}
// --snip--
}
ในคราวนี้ ก่อนที่เราจะสร้างเธรดใหม่ตัวแรก เราได้เรียก clone บนตัวส่ง tx ซึ่งจะทำให้เราได้ตัวส่งตัวใหม่มาอีกหนึ่งตัว เพื่อส่งมอบให้เธรดแรกนำไปใช้ จากนั้นเราจึงส่งตัวส่งตัวเดิมให้กับเธรดที่สอง ทำให้เรามีสองเธรดที่ต่างส่งข้อความไปยังตัวรับตัวเดียวกันได้พร้อมๆ กัน
เมื่อคุณรันโค้ด เอาต์พุตของคุณควรมีหน้าตาประมาณนี้:
Got: hi
Got: more
Got: from
Got: messages
Got: for
Got: the
Got: thread
Got: you
คุณอาจเห็นลำดับของข้อความเหล่านี้แตกต่างกันไป ขึ้นอยู่กับระบบของคุณ ซึ่งนี่คือเสน่ห์และความท้าทายของการเขียนโปรแกรมแบบทำงานพร้อมกัน หากคุณลองปรับเปลี่ยนระยะเวลาหน่วงใน thread::sleep บนแต่ละเธรด การรันในแต่ละครั้งก็จะยิ่งให้ลำดับผลลัพธ์ที่หลากหลายและคาดเดาได้ยากขึ้น
เมื่อเราได้เห็นการทำงานของแชนเนลไปแล้ว ต่อไปเรามาดูอีกหนึ่งแนวทางสำคัญในการทำงานพร้อมกัน นั่นคือการแชร์สถานะร่วมกันครับ