ใช้เธรดรันโค้ดพร้อมกัน
ในระบบปฏิบัติการปัจจุบันส่วนใหญ่ โค้ดของโปรแกรมที่กำลังทำงานจะรันอยู่ภายใน_โปรเซส_ (process) หนึ่ง และระบบปฏิบัติการจะทำหน้าที่จัดการหลายโปรเซสไปพร้อมๆ กัน นอกจากนี้ ภายในโปรแกรมเดียวกัน คุณยังสามารถแบ่งการทำงานออกเป็นส่วนๆ ที่เป็นอิสระต่อกันและรันไปพร้อมๆ กันได้ ซึ่งกลไกหรือฟีเจอร์ที่ใช้รันส่วนต่างๆ เหล่านี้เรียกว่า_เธรด_ (threads) ตัวอย่างเช่น เว็บเซิร์ฟเวอร์อาจทำงานด้วยหลายเธรด เพื่อให้สามารถตอบสนองคำขอ (requests) ได้มากกว่าหนึ่งคำขอในเวลาเดียวกัน
การแบ่งการคำนวณในโปรแกรมของคุณออกเป็นหลายเธรดเพื่อรันหลายงานในเวลาเดียวกันสามารถช่วยเพิ่มประสิทธิภาพได้ แต่มันก็เพิ่มความซับซ้อนตามมาด้วยเช่นกัน เนื่องจากเธรดสามารถรันไปพร้อมๆ กันได้ จึงไม่มีหลักประกันโดยธรรมชาติว่าส่วนต่างๆ ของโค้ดบนแต่ละเธรดจะทำงานตามลำดับใด ซึ่งอาจนำไปสู่ปัญหาต่างๆ เช่น:
- สภาวะแย่งชิง (race conditions) เมื่อเธรดต่างๆ เข้าถึงข้อมูลหรือทรัพยากรด้วยลำดับที่ไม่แน่นอนหรือไม่สอดคล้องกัน
- เดดล็อก (deadlocks) เมื่อเธรดสองตัวต่างรอคอยซึ่งกันและกัน ส่งผลให้ทั้งสองเธรดไม่สามารถทำงานต่อได้
- บั๊กที่เกิดขึ้นเฉพาะในบางสถานการณ์เท่านั้น ทำให้ยากต่อการจำลองปัญหาและแก้ไขได้อย่างแน่นอน
Rust พยายามช่วยลดผลกระทบเชิงลบจากการใช้เธรด แต่ถึงกระนั้น การเขียนโปรแกรมในบริบทที่มีหลายเธรดก็ยังต้องอาศัยความรอบคอบ และจำเป็นต้องจัดโครงสร้างโค้ดที่แตกต่างไปจากโปรแกรมที่รันบนเธรดเดียว
ภาษาโปรแกรมต่างๆ มีวิธีอิมพลีเมนต์เธรดที่แตกต่างกันไปสองสามวิธี และระบบปฏิบัติการส่วนใหญ่ก็มี API ให้ภาษาโปรแกรมเรียกใช้เพื่อสร้างเธรดใหม่ ไลบรารีมาตรฐานของ Rust ใช้โมเดลการทำงานของเธรดแบบ 1:1 กล่าวคือ โปรแกรมจะใช้เธรดของระบบปฏิบัติการ 1 ตัวต่อเธรดของภาษา Rust 1 ตัว นอกจากนี้ยังมีเครต (crates) อื่นๆ ที่อิมพลีเมนต์โมเดลเธรดแบบทางเลือก ซึ่งมีการแลกเปลี่ยนข้อดีข้อเสีย (trade-offs) ที่แตกต่างจากโมเดล 1:1 (ทั้งนี้ ระบบ async ของ Rust ซึ่งเราจะได้เรียนรู้ในบทถัดไป ก็เป็นอีกหนึ่งแนวทางในการจัดการกับการทำงานพร้อมกันเช่นกัน)
การสร้างเธรดใหม่ด้วย spawn
ในการสร้างเธรดใหม่ เราจะเรียกใช้ฟังก์ชัน thread::spawn และส่งโคลเชอร์ (closure) เข้าไป (เราได้พูดถึงโคลเชอร์ไปแล้วในบทที่ 13) ซึ่งภายในโคลเชอร์จะบรรจุโค้ดที่เราต้องการให้รันบนเธรดใหม่ ตัวอย่างในลิสติ้ง 16-1 จะพิมพ์ข้อความบางส่วนจากเธรดหลัก (main thread) และข้อความอื่นๆ จากเธรดใหม่ที่สร้างขึ้น
use std::thread;
use std::time::Duration;
fn main() {
thread::spawn(|| {
for i in 1..10 {
println!("hi number {i} from the spawned thread!");
thread::sleep(Duration::from_millis(1));
}
});
for i in 1..5 {
println!("hi number {i} from the main thread!");
thread::sleep(Duration::from_millis(1));
}
}
โปรดสังเกตว่าเมื่อเธรดหลักของโปรแกรม Rust ทำงานเสร็จสิ้น เธรดใหม่ทั้งหมดที่ถูกสร้างขึ้นจะถูกยุติการทำงานลงทันที ไม่ว่าเธรดเหล่านั้นจะทำงานเสร็จแล้วหรือไม่ก็ตาม เอาต์พุตจากการรันโปรแกรมนี้ในแต่ละครั้งอาจแตกต่างกันไปเล็กน้อย แต่จะมีลักษณะคล้ายกับตัวอย่างต่อไปนี้:
hi number 1 from the main thread!
hi number 1 from the spawned thread!
hi number 2 from the main thread!
hi number 2 from the spawned thread!
hi number 3 from the main thread!
hi number 3 from the spawned thread!
hi number 4 from the main thread!
hi number 4 from the spawned thread!
hi number 5 from the spawned thread!
การเรียก thread::sleep จะบังคับให้เธรดหยุดการทำงานชั่วคราวเป็นระยะเวลาสั้นๆ เพื่อเปิดโอกาสให้เธรดอื่นได้ทำงาน เธรดต่างๆ อาจจะสลับกันทำงาน แต่ก็ไม่มีการรับประกัน เพราะขึ้นอยู่กับว่าระบบปฏิบัติการจัดตารางเวลาการทำงาน (schedule) ให้กับเธรดอย่างไร ในการรันรอบนี้ เธรดหลักพิมพ์ออกมาก่อน แม้ว่าคำสั่งพิมพ์ของเธรดใหม่จะปรากฏเป็นบรรทัดแรกในโค้ดก็ตาม และถึงแม้ว่าเราจะสั่งให้เธรดใหม่พิมพ์วนลูปไปจนกระทั่ง i เท่ากับ 9 แต่มันก็ทำได้ถึงแค่ 5 ก่อนที่เธรดหลักจะทำงานเสร็จและปิดโปรแกรมไป
หากคุณรันโค้ดนี้แล้วเห็นเพียงเอาต์พุตจากเธรดหลัก หรือไม่เห็นการสลับกันของเอาต์พุตเลย ให้ลองเพิ่มตัวเลขในช่วง (range) ของลูป เพื่อเปิดโอกาสให้ระบบปฏิบัติการสลับการทำงานระหว่างเธรดได้มากขึ้น
การรอให้เธรดทั้งหมดทำงานเสร็จ
โค้ดในลิสติ้ง 16-1 ไม่เพียงแต่มักจะหยุดการทำงานของเธรดใหม่ก่อนเวลาอันควรเนื่องจากเธรดหลักทำงานเสร็จสิ้นก่อนเท่านั้น แต่เนื่องจากไม่มีการรับประกันลำดับการทำงานของแต่ละเธรด เราจึงไม่สามารถรับประกันได้เลยว่าเธรดใหม่จะมีโอกาสได้เริ่มรันหรือไม่!
เราสามารถแก้ปัญหาที่เธรดใหม่ไม่ได้รันหรือหยุดทำงานก่อนเวลาอันควรได้ โดยการเก็บค่าที่คืนกลับมาจาก thread::spawn ไว้ในตัวแปร ซึ่งชนิดข้อมูลที่คืนกลับมาจาก thread::spawn คือ JoinHandle<T> โดย JoinHandle<T> คือค่าที่ถือครองความเป็นเจ้าของ ซึ่งเมื่อเราเรียกเมธอด join บนแฮนเดิลนี้ มันจะรอจนกว่าเธรดของมันจะทำงานเสร็จสิ้น ลิสติ้ง 16-2 แสดงวิธีใช้ JoinHandle<T> ของเธรดที่เราสร้างในลิสติ้ง 16-1 และการเรียก join เพื่อให้แน่ใจว่าเธรดใหม่จะรันจนเสร็จก่อนที่ main จะจบการทำงาน
use std::thread;
use std::time::Duration;
fn main() {
let handle = thread::spawn(|| {
for i in 1..10 {
println!("hi number {i} from the spawned thread!");
thread::sleep(Duration::from_millis(1));
}
});
for i in 1..5 {
println!("hi number {i} from the main thread!");
thread::sleep(Duration::from_millis(1));
}
handle.join().unwrap();
}
การเรียก join บนแฮนเดิล (handle) จะบล็อก (block) เธรดที่กำลังทำงานอยู่ ณ ขณะนั้นไว้ จนกว่าเธรดที่แฮนเดิลนั้นเป็นตัวแทนจะทำงานเสร็จสิ้น การบล็อก เธรดหมายความว่าเธรดดังกล่าวจะถูกระงับไม่ให้ทำงานอื่นต่อหรือจบการทำงาน และเนื่องจากเราวางการเรียก join ไว้หลังจากลูป for ของเธรดหลัก การรันลิสติ้ง 16-2 จึงควรให้เอาต์พุตที่คล้ายกับสิ่งนี้:
hi number 1 from the main thread!
hi number 2 from the main thread!
hi number 1 from the spawned thread!
hi number 3 from the main thread!
hi number 2 from the spawned thread!
hi number 4 from the main thread!
hi number 3 from the spawned thread!
hi number 4 from the spawned thread!
hi number 5 from the spawned thread!
hi number 6 from the spawned thread!
hi number 7 from the spawned thread!
hi number 8 from the spawned thread!
hi number 9 from the spawned thread!
ทั้งสองเธรดยังคงสลับกันทำงาน แต่เธรดหลักจะหยุดรอเนื่องจากมีการเรียก handle.join() และจะไม่จบการทำงานจนกว่าเธรดใหม่จะทำงานเสร็จสิ้น
แต่ลองมาดูกันว่าจะเกิดอะไรขึ้นหากเราย้าย handle.join() มาไว้ก่อนหน้าลูป for ใน main แทน ดังนี้:
use std::thread;
use std::time::Duration;
fn main() {
let handle = thread::spawn(|| {
for i in 1..10 {
println!("hi number {i} from the spawned thread!");
thread::sleep(Duration::from_millis(1));
}
});
handle.join().unwrap();
for i in 1..5 {
println!("hi number {i} from the main thread!");
thread::sleep(Duration::from_millis(1));
}
}
เธรดหลักจะรอจนกว่าเธรดใหม่จะทำงานเสร็จสิ้นก่อน แล้วจึงค่อยเริ่มรันลูป for ของตัวเอง ทำให้เอาต์พุตไม่สลับกันอีกต่อไป ดังที่แสดงที่นี่:
hi number 1 from the spawned thread!
hi number 2 from the spawned thread!
hi number 3 from the spawned thread!
hi number 4 from the spawned thread!
hi number 5 from the spawned thread!
hi number 6 from the spawned thread!
hi number 7 from the spawned thread!
hi number 8 from the spawned thread!
hi number 9 from the spawned thread!
hi number 1 from the main thread!
hi number 2 from the main thread!
hi number 3 from the main thread!
hi number 4 from the main thread!
รายละเอียดเล็กๆ น้อยๆ เช่น ตำแหน่งที่มีการเรียก join สามารถส่งผลได้ว่าเธรดของคุณจะทำงานไปพร้อมๆ กันหรือไม่
การใช้โคลเชอร์ move กับเธรด
เรามักจะใช้คำสงวน move ร่วมกับโคลเชอร์ที่ส่งไปยัง thread::spawn บ่อยครั้ง เนื่องจากโคลเชอร์จะรับความเป็นเจ้าของ (ownership) ในค่าต่างๆ ที่มันใช้งานมาจากสภาพแวดล้อม ซึ่งเป็นการถ่ายโอนความเป็นเจ้าของค่าเหล่านั้นจากเธรดหนึ่งไปยังอีกเธรดหนึ่ง ใน“การจับเรเฟอเรนซ์หรือการย้ายความเป็นเจ้าของ” ในบทที่ 13 เราได้พูดคุยถึง move ในบริบทของโคลเชอร์ ตอนนี้เราจะมุ่งเน้นไปที่ปฏิสัมพันธ์ระหว่าง move กับ thread::spawn มากขึ้น
โปรดสังเกตว่าในลิสติ้ง 16-1 โคลเชอร์ที่เราส่งให้ thread::spawn ไม่ได้รับอาร์กิวเมนต์ใดๆ: เราไม่ได้ใช้ข้อมูลใดจากเธรดหลักในโค้ดของเธรดใหม่เลย แต่หากเราต้องการนำข้อมูลจากเธรดหลักไปใช้งานในเธรดใหม่ โคลเชอร์ของเธรดใหม่จำเป็นต้องจับค่าที่ต้องการจากสภาพแวดล้อม ลิสติ้ง 16-3 แสดงตัวอย่างความพยายามสร้างเวกเตอร์ในเธรดหลักแล้วนำไปใช้งานในเธรดใหม่ อย่างไรก็ตาม โค้ดนี้จะยังคอมไพล์ไม่ผ่าน ดังที่คุณจะได้เห็นในไม่ช้า
use std::thread;
fn main() {
let v = vec![1, 2, 3];
let handle = thread::spawn(|| {
println!("Here's a vector: {v:?}");
});
handle.join().unwrap();
}
เนื่องจากโคลเชอร์เรียกใช้ v มันจึงจับค่า v เข้ามาเป็นส่วนหนึ่งของสภาพแวดล้อมของโคลเชอร์ และเนื่องจาก thread::spawn รันโคลเชอร์นี้บนเธรดใหม่ เราจึงควรสามารถเข้าถึง v ภายในเธรดใหม่นั้นได้ แต่เมื่อเราคอมไพล์ตัวอย่างนี้ เราจะพบกับข้อผิดพลาดต่อไปนี้:
$ cargo run
Compiling threads v0.1.0 (file:///projects/threads)
error[E0373]: closure may outlive the current function, but it borrows `v`, which is owned by the current function
--> src/main.rs:6:32
|
6 | let handle = thread::spawn(|| {
| ^^ may outlive borrowed value `v`
7 | println!("Here's a vector: {v:?}");
| - `v` is borrowed here
|
note: function requires argument type to outlive `'static`
--> src/main.rs:6:18
|
6 | let handle = thread::spawn(|| {
| __________________^
7 | | println!("Here's a vector: {v:?}");
8 | | });
| |______^
help: to force the closure to take ownership of `v` (and any other referenced variables), use the `move` keyword
|
6 | let handle = thread::spawn(move || {
| ++++
For more information about this error, try `rustc --explain E0373`.
error: could not compile `threads` (bin "threads") due to 1 previous error
Rust จะ_อนุมาน_วิธีที่โคลเชอร์ควรใช้ในการจับค่า v และเนื่องจากคำสั่ง println! ต้องการเพียงเรเฟอเรนซ์ไปยัง v เท่านั้น โคลเชอร์จึงพยายามยืม (borrow) ค่า v แต่ปัญหาคือ: Rust ไม่สามารถล่วงรู้ได้เลยว่าเธรดใหม่จะทำงานนานเท่าใด จึงไม่อาจรับประกันได้ว่าเรเฟอเรนซ์ที่ชี้ไปยัง v นั้นจะยังคงใช้งานได้ตลอดไปหรือไม่
ลิสติ้ง 16-4 แสดงสถานการณ์ที่ชี้ให้เห็นชัดเจนว่าทำไมเรเฟอเรนซ์ไปยัง v จึงอาจกลายเป็นเรเฟอเรนซ์ที่ไม่ถูกต้องได้
use std::thread;
fn main() {
let v = vec![1, 2, 3];
let handle = thread::spawn(|| {
println!("Here's a vector: {v:?}");
});
drop(v); // oh no!
handle.join().unwrap();
}
หาก Rust ยอมให้โค้ดนี้ทำงาน มีความเป็นไปได้ว่าเธรดใหม่ที่ถูกสร้างขึ้นอาจยังไม่ทันได้เริ่มทำงานเลยด้วยซ้ำ ในขณะที่เธรดหลักทำงานต่อและสั่งทิ้ง (drop) ค่า v ทันทีด้วยฟังก์ชัน drop ที่เราได้เรียนรู้ในบทที่ 15 เมื่อเธรดใหม่ได้คิวเริ่มทำงานในภายหลัง ค่า v ก็ไม่อยู่ในหน่วยความจำอีกต่อไปแล้ว ส่งผลให้เรเฟอเรนซ์ที่เธรดใหม่ถืออยู่ชี้ไปยังหน่วยความจำที่ไม่ถูกต้องทันที!
ในการแก้ข้อผิดพลาดของคอมไพเลอร์ในลิสติ้ง 16-3 เราสามารถใช้คำแนะนำจากข้อความแสดงข้อผิดพลาดได้:
help: to force the closure to take ownership of `v` (and any other referenced variables), use the `move` keyword
|
6 | let handle = thread::spawn(move || {
| ++++
การใส่คำสงวน move ไว้หน้าโคลเชอร์จะบังคับให้โคลเชอร์รับสิทธิ์ความเป็นเจ้าของในค่าต่างๆ ที่มันใช้งานโดยตรง แทนที่จะปล่อยให้ Rust อนุมานว่าควรยืมค่านั้นมา การแก้ไขลิสติ้ง 16-3 ดังแสดงในลิสติ้ง 16-5 จะทำให้โค้ดสามารถคอมไพล์ผ่านและทำงานได้ตามที่เราตั้งใจไว้
use std::thread;
fn main() {
let v = vec![1, 2, 3];
let handle = thread::spawn(move || {
println!("Here's a vector: {v:?}");
});
handle.join().unwrap();
}
เราอาจสงสัยว่าจะลองใช้วิธีเดียวกันนี้เพื่อแก้ไขโค้ดในลิสติ้ง 16-4 ที่เธรดหลักเรียก drop ได้หรือไม่ แต่การเติม move จะไม่ช่วยให้โค้ดนั้นทำงานได้ เพราะสิ่งที่ลิสติ้ง 16-4 พยายามทำนั้นขัดต่อกฎด้วยเหตุผลอีกประการหนึ่ง: หากเราใส่ move ให้กับโคลเชอร์ เราจะย้ายสิทธิ์ความเป็นเจ้าของของ v เข้าไปในโคลเชอร์ ทำให้เธรดหลักไม่สามารถเรียก drop บนตัวแปร v ได้อีกต่อไป คอมไพเลอร์จะแจ้งข้อผิดพลาดดังนี้แทน:
$ cargo run
Compiling threads v0.1.0 (file:///projects/threads)
error[E0382]: use of moved value: `v`
--> src/main.rs:10:10
|
4 | let v = vec![1, 2, 3];
| - move occurs because `v` has type `Vec<i32>`, which does not implement the `Copy` trait
5 |
6 | let handle = thread::spawn(move || {
| ------- value moved into closure here
7 | println!("Here's a vector: {v:?}");
| - variable moved due to use in closure
...
10 | drop(v); // oh no!
| ^ value used here after move
|
help: consider cloning the value before moving it into the closure
|
6 ~ let value = v.clone();
7 ~ let handle = thread::spawn(move || {
8 ~ println!("Here's a vector: {value:?}");
|
For more information about this error, try `rustc --explain E0382`.
error: could not compile `threads` (bin "threads") due to 1 previous error
กฎความเป็นเจ้าของของ Rust ช่วยปกป้องเราไว้อีกครั้ง! ในลิสติ้ง 16-3 เราพบข้อผิดพลาดเพราะ Rust ทำงานด้วยความระมัดระวังสูงสุด โดยเลือกที่จะยืม v ให้กับเธรดใหม่ ซึ่งในทางทฤษฎีแล้ว เธรดหลักอาจทำให้เรเฟอเรนซ์นั้นกลายเป็นโมฆะได้ แต่เมื่อเราสั่งให้ย้ายสิทธิ์ความเป็นเจ้าของของ v ไปยังเธรดใหม่ Rust ก็มั่นใจได้ทันทีว่าเธรดหลักจะไม่ยุ่งเกี่ยวกับ v อีกต่อไป ส่วนในลิสติ้ง 16-4 หากเราพยายามทำแบบเดียวกัน ก็จะกลายเป็นการละเมิดกฎความเป็นเจ้าของเมื่อเราพยายามเรียกใช้ v ในเธรดหลักซ้ำอีก คำสงวน move มีไว้เพื่อแทนที่พฤติกรรมการยืมโดยปริยายของ Rust แต่ไม่ได้เปิดช่องให้เราละเมิดกฎความเป็นเจ้าของได้แต่อย่างใด
เมื่อเราเข้าใจแล้วว่าเธรดคืออะไร และเมธอดต่างๆ ใน API ของเธรดทำงานอย่างไร ต่อไปเรามาดูสถานการณ์การใช้งานจริงในรูปแบบต่างๆ ของเธรดกันครับ