การทำงานพร้อมกันแบบใช้สถานะร่วมกัน
การส่งผ่านข้อความ (message passing) เป็นวิธีที่ดีในการจัดการการทำงานพร้อมกัน (concurrency) แต่นั่นไม่ใช่วิธีเดียว อีกวิธีหนึ่งคือการให้หลายๆ เธรดสามารถเข้าถึงข้อมูลที่ใช้งานร่วมกัน (shared data) ได้ ลองพิจารณาส่วนหนึ่งของสโลแกนจากเอกสารภาษา Go อีกครั้ง: “อย่าสื่อสารกันด้วยการแชร์หน่วยความจำ”
แล้วการสื่อสารด้วยการแชร์หน่วยความจำจะมีลักษณะเป็นอย่างไร? นอกจากนี้ ทำไมผู้ที่สนับสนุนการส่งผ่านข้อความจึงเตือนไม่ให้ใช้การแชร์หน่วยความจำ?
ในแง่หนึ่ง แชนเนล (channel) ในภาษาโปรแกรมใดๆ จะมีความคล้ายคลึงกับระบบความเป็นเจ้าของแบบเดี่ยว (single ownership) เพราะเมื่อคุณส่งค่าผ่านแชนเนลไปแล้ว คุณก็ไม่ควรนำค่านั้นกลับมาใช้งานอีกต่อไป ส่วนการทำงานพร้อมกันโดยใช้หน่วยความจำร่วมกันนั้นจะคล้ายกับความเป็นเจ้าของหลายราย (multiple ownership) นั่นคือหลายเธรดสามารถเข้าถึงตำแหน่งหน่วยความจำเดียวกันได้ในเวลาเดียวกัน ดังที่คุณได้เห็นในบทที่ 15 ว่าสมาร์ตพอยน์เตอร์ (smart pointer) ช่วยให้สามารถมีความเป็นเจ้าของหลายรายได้ แต่ความเป็นเจ้าของหลายรายก็เพิ่มความซับซ้อนตามมา เพราะเราจำเป็นต้องบริหารจัดการเจ้าของแต่ละรายให้ถูกต้อง อย่างไรก็ตาม ระบบชนิดข้อมูลและกฎความเป็นเจ้าของของ Rust จะช่วยให้คุณจัดการเรื่องเหล่านี้ได้อย่างถูกต้องและปลอดภัย ตัวอย่างเช่น ลองมาดูมิวเท็กซ์ (mutex) ซึ่งเป็นหนึ่งในพริมิทีฟการทำงานพร้อมกัน (concurrency primitive) ที่นิยมใช้กันทั่วไปสำหรับหน่วยความจำร่วม
การควบคุมการเข้าถึงด้วยมิวเท็กซ์
คำว่า มิวเท็กซ์ (mutex) เป็นคำย่อของ mutual exclusion (การกีดกันซึ่งกันและกัน) ซึ่งหมายความว่ามิวเท็กซ์จะอนุญาตให้มีเพียงเธรดเดียวเท่านั้นที่สามารถเข้าถึงข้อมูลได้ ณ ขณะใดขณะหนึ่ง ในการเข้าถึงข้อมูลในมิวเท็กซ์ เธรดจะต้องส่งสัญญาณขอก่อนโดยการขอถือครองล็อก (acquire the lock) ของมิวเท็กซ์ โดยที่_ล็อก_ (lock) เป็นโครงสร้างข้อมูลส่วนหนึ่งของมิวเท็กซ์ที่คอยติดตามว่าใครคือผู้ที่ถือครองสิทธิ์การเข้าถึงข้อมูลแต่เพียงผู้เดียวในขณะนั้น ดังนั้น เราจึงมักพูดว่ามิวเท็กซ์ทำหน้าที่_เฝ้าปกป้อง_ (guard) ข้อมูลที่มันเก็บรักษาไว้ผ่านระบบล็อก
มิวเท็กซ์ขึ้นชื่อเรื่องความยุ่งยากในการใช้งาน เพราะคุณต้องจำกฎเหล็กสองข้อนี้ให้ดี:
- คุณต้องพยายามขอถือครองล็อกก่อนจะนำข้อมูลไปใช้งาน
- เมื่อคุณใช้งานข้อมูลที่มิวเท็กซ์เฝ้าปกป้องเสร็จเรียบร้อยแล้ว คุณต้องปลดล็อกข้อมูลเพื่อให้เธรดอื่นสามารถเข้ามาถือครองล็อกได้
หากจะเปรียบเทียบมิวเท็กซ์กับสถานการณ์ในชีวิตจริง ลองนึกภาพเวทีเสวนาในงานประชุมที่มีไมโครโฟนเพียงตัวเดียว ก่อนที่นักเสวนาจะพูดได้ พวกเขาจะต้องขอหรือส่งสัญญาณว่าต้องการใช้ไมโครโฟน เมื่อได้รับไมโครโฟนมาแล้ว พวกเขาสามารถพูดได้นานเท่าที่ต้องการ แล้วจึงส่งไมโครโฟนต่อให้นักเสวนาคนถัดไปที่ขอพูด หากนักเสวนาคนหนึ่งลืมส่งต่อไมโครโฟนเมื่อใช้เสร็จแล้ว ก็จะไม่มีใครอื่นสามารถพูดได้เลย และหากการบริหารจัดการไมโครโฟนที่ใช้ร่วมกันนี้ผิดพลาด การเสวนาก็จะไม่เป็นไปตามที่วางแผนไว้!
การจัดการมิวเท็กซ์ให้ถูกต้องสมบูรณ์นั้นอาจซับซ้อนอย่างเหลือเชื่อ ซึ่งเป็นเหตุผลที่หลายคนชื่นชอบแชนเนลมาก อย่างไรก็ตาม ต้องขอบคุณระบบชนิดข้อมูลและกฎความเป็นเจ้าของของ Rust คุณจึงแทบไม่มีโอกาสทำการล็อกและปลดล็อกผิดพลาดเลย
API ของ Mutex<T>
เพื่อดูตัวอย่างวิธีใช้มิวเท็กซ์ เรามาเริ่มจากการใช้งานในบริบทแบบเธรดเดียวก่อน ดังแสดงในลิสติ้ง 16-12
use std::sync::Mutex;
fn main() {
let m = Mutex::new(5);
{
let mut num = m.lock().unwrap();
*num = 6;
}
println!("m = {m:?}");
}
เช่นเดียวกับหลายๆ ชนิดข้อมูล เราสร้าง Mutex<T> ขึ้นมาได้โดยใช้ฟังก์ชันสัมพันธ์ (associated function) new และหากต้องการเข้าถึงข้อมูลภายในมิวเท็กซ์ เราจะต้องเรียกใช้เมธอด lock เพื่อขอถือครองล็อก ซึ่งการเรียกนี้จะบล็อก (block) การทำงานของเธรดปัจจุบันไว้ จนกว่าจะถึงคิวที่เธรดของเราได้รับล็อกมาครอบครอง
การเรียก lock จะล้มเหลวหากเธรดอื่นที่ถือครองล็อกอยู่ก่อนหน้าเกิดแพนิก (panic) ขึ้น เพราะในกรณีนั้นจะไม่มีใครสามารถขอถือครองล็อกได้อีกต่อไป เราจึงเลือกใช้ unwrap เพื่อให้เธรดนี้แพนิกตามไปด้วยหากตกอยู่ในสถานการณ์ดังกล่าว
เมื่อถือครองล็อกสำเร็จแล้ว เราสามารถปฏิบัติต่อค่าที่ได้รับกลับมา (ซึ่งในที่นี้คือ num) เสมือนเป็นเรเฟอเรนซ์แบบเปลี่ยนแปลงค่าได้ (mutable reference) ไปยังข้อมูลข้างในได้ทันที โดยระบบชนิดข้อมูลจะคอยรับประกันว่าเราต้องถือครองล็อกก่อนใช้งานค่าใน m เสมอ ชนิดข้อมูลของ m คือ Mutex<i32> ไม่ใช่ i32 เราจึง_จำเป็นต้อง_เรียก lock ก่อนจึงจะเข้าถึงค่า i32 ได้ เราไม่มีทางลืมขั้นตอนนี้ได้เลย เพราะหากไม่ทำ ระบบชนิดข้อมูลจะไม่ยอมให้เราเข้าถึงค่า i32 ข้างในอย่างเด็ดขาด
แท้จริงแล้วการเรียก lock จะคืนค่าชนิด MutexGuard ที่ถูกห่อหุ้มไว้ใน LockResult ซึ่งเราจัดการด้วยการเรียก unwrap โดยชนิดข้อมูล MutexGuard นั้นได้อิมพลีเมนต์ Deref เพื่อชี้ไปยังข้อมูลภายใน และยังอิมพลีเมนต์ Drop เพื่อปล่อยล็อกโดยอัตโนมัติเมื่อ MutexGuard หลุดออกจากสโคป (ซึ่งเกิดขึ้นเมื่อสิ้นสุดบล็อกสโคปชั้นใน) ส่งผลให้เราไม่ต้องกังวลว่าจะลืมปล่อยล็อกจนขัดขวางไม่ให้เธรดอื่นใช้งานมิวเท็กซ์ เพราะกระบวนการปล่อยล็อกจะทำงานโดยอัตโนมัติเสมอ
หลังจากทิ้งล็อกไปแล้ว เราสามารถพิมพ์ค่าของมิวเท็กซ์ออกมาดู และจะเห็นว่าค่า i32 ภายในถูกแก้ไขเป็น 6 ได้เรียบร้อยแล้ว
การเข้าถึง Mutex<T> ร่วมกัน
คราวนี้เรามาลองแชร์ค่าร่วมกันระหว่างหลายๆ เธรดโดยใช้ Mutex<T> กันดูบ้าง เราจะสร้างเธรดขึ้นมา 10 เธรด และให้แต่ละเธรดเพิ่มค่าตัวนับขึ้นทีละ 1 เพื่อให้ตัวนับวิ่งจาก 0 ไปจนถึง 10 ตัวอย่างในลิสติ้ง 16-13 นี้จะมีข้อผิดพลาดจากคอมไพเลอร์ ซึ่งเราจะใช้ข้อผิดพลาดดังกล่าวมาทำความเข้าใจการทำงานของ Mutex<T> และดูว่า Rust ช่วยให้เราใช้งานได้อย่างถูกต้องอย่างไร
use std::sync::Mutex;
use std::thread;
fn main() {
let counter = Mutex::new(0);
let mut handles = vec![];
for _ in 0..10 {
let handle = thread::spawn(move || {
let mut num = counter.lock().unwrap();
*num += 1;
});
handles.push(handle);
}
for handle in handles {
handle.join().unwrap();
}
println!("Result: {}", *counter.lock().unwrap());
}
เราสร้างตัวแปร counter เพื่อเก็บ i32 ไว้ภายใน Mutex<T> เช่นเดียวกับในลิสติ้ง 16-12 จากนั้นเราสร้างเธรดขึ้นมา 10 เธรดด้วยการวนลูปตามช่วงตัวเลข และใช้ thread::spawn โดยส่งโคลเชอร์ตัวเดียวกันให้ทุกเธรด นั่นคือโคลเชอร์ที่จะย้าย (move) ตัวนับเข้าไปในเธรด ขอถือครองล็อกบน Mutex<T> ด้วยการเรียกเมธอด lock แล้วบวก 1 เข้าไปที่ค่าในมิวเท็กซ์ เมื่อเธรดทำงานในโคลเชอร์เสร็จสิ้น num จะหลุดออกจากสโคปและปล่อยล็อก ทำให้เธรดตัวอื่นสามารถเข้ามาถือครองล็อกต่อได้
ในเธรดหลัก เราเก็บแฮนเดิลการรวม (join handle) ทั้งหมดไว้ จากนั้นเรียก join บนแต่ละแฮนเดิลเหมือนในลิสติ้ง 16-2 เพื่อรอให้เธรดทั้งหมดทำงานจนเสร็จสิ้น จากนั้นเธรดหลักจึงจะขอถือครองล็อกแล้วพิมพ์ผลลัพธ์ของโปรแกรมนี้ออกมา
เราได้บอกเป็นนัยไว้แล้วว่าตัวอย่างนี้จะไม่คอมไพล์ ตอนนี้มาดูกันว่าทำไม!
$ cargo run
Compiling shared-state v0.1.0 (file:///projects/shared-state)
error[E0382]: borrow of moved value: `counter`
--> src/main.rs:21:29
|
5 | let counter = Mutex::new(0);
| ------- move occurs because `counter` has type `std::sync::Mutex<i32>`, which does not implement the `Copy` trait
...
8 | for _ in 0..10 {
| -------------- inside of this loop
9 | let handle = thread::spawn(move || {
| ------- value moved into closure here, in previous iteration of loop
...
21 | println!("Result: {}", *counter.lock().unwrap());
| ^^^^^^^ value borrowed here after move
For more information about this error, try `rustc --explain E0382`.
error: could not compile `shared-state` (bin "shared-state") due to 1 previous error
ข้อความแจ้งข้อผิดพลาดระบุว่าค่า counter ถูกย้าย (move) ไปแล้วตั้งแต่การวนซ้ำรอบก่อนหน้าของลูป Rust กำลังบอกเราว่าเราไม่สามารถย้ายความเป็นเจ้าของของล็อก counter ไปให้กับหลายๆ เธรดได้พร้อมกัน เรามาแก้ไขข้อผิดพลาดนี้ด้วยวิธีจัดการความเป็นเจ้าของหลายราย (multiple ownership) ตามที่เคยเรียนรู้กันมาในบทที่ 15
ความเป็นเจ้าของหลายรายกับหลายเธรด
ในบทที่ 15 เราทำให้ค่ามีเจ้าของได้หลายรายโดยใช้สมาร์ตพอยน์เตอร์ Rc<T> เพื่อสร้างค่าที่มีการนับจำนวนเรเฟอเรนซ์ (reference-counted) เราลองมาทำแบบเดียวกันในที่นี้แล้วดูผลลัพธ์กัน เราจะนำ Rc<T> มาห่อหุ้ม Mutex<T> ในลิสติ้ง 16-14 และโคลน (clone) Rc<T> ก่อนที่จะย้ายความเป็นเจ้าของไปยังเธรด
use std::rc::Rc;
use std::sync::Mutex;
use std::thread;
fn main() {
let counter = Rc::new(Mutex::new(0));
let mut handles = vec![];
for _ in 0..10 {
let counter = Rc::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!("Result: {}", *counter.lock().unwrap());
}
เมื่อสั่งคอมไพล์อีกครั้ง เรากลับพบกับ… ข้อผิดพลาดชุดใหม่! แต่คอมไพเลอร์กำลังสอนอะไรหลายอย่างให้กับเรา:
$ cargo run
Compiling shared-state v0.1.0 (file:///projects/shared-state)
error[E0277]: `Rc<std::sync::Mutex<i32>>` cannot be sent between threads safely
--> src/main.rs:11:36
|
11 | let handle = thread::spawn(move || {
| ------------- ^------
| | |
| ______________________|_____________within this `{closure@src/main.rs:11:36: 11:43}`
| | |
| | required by a bound introduced by this call
12 | | let mut num = counter.lock().unwrap();
13 | |
14 | | *num += 1;
15 | | });
| |_________^ `Rc<std::sync::Mutex<i32>>` cannot be sent between threads safely
|
= help: within `{closure@src/main.rs:11:36: 11:43}`, the trait `Send` is not implemented for `Rc<std::sync::Mutex<i32>>`
note: required because it's used within this closure
--> src/main.rs:11:36
|
11 | let handle = thread::spawn(move || {
| ^^^^^^^
note: required by a bound in `spawn`
--> /rustc/88d9e12ae178fab0fb5cc050a94da85685d449ea/library/std/src/thread/functions.rs:125:0
For more information about this error, try `rustc --explain E0277`.
error: could not compile `shared-state` (bin "shared-state") due to 1 previous error
ข้อความแจ้งข้อผิดพลาดนี้ยาวพอสมควรทีเดียว! แต่ส่วนสำคัญที่สุดที่ควรโฟกัสคือ: `Rc<Mutex<i32>>` cannot be sent between threads safely และคอมไพเลอร์ยังบอกเหตุผลประกอบไว้ด้วยว่า: the trait `Send` is not implemented for `Rc<Mutex<i32>>` เราจะพูดถึงเทรต Send ในหัวข้อถัดไป ซึ่งเป็นหนึ่งในเทรตที่คอยรับประกันว่าชนิดข้อมูลที่เรานำมาใช้กับเธรดนั้นถูกออกแบบมาให้ใช้งานในการทำงานพร้อมกันได้อย่างปลอดภัย
น่าเสียดายที่ Rc<T> ไม่ปลอดภัยสำหรับการแชร์ข้ามเธรด เพราะในขณะที่ Rc<T> จัดการจำนวนเรเฟอเรนซ์ มันจะเพิ่มค่านับทุกครั้งที่มีการเรียก clone และลดค่านับลงเมื่อโคลนแต่ละตัวถูกทำลาย (drop) ทว่ามันไม่ได้ใช้พริมิทีฟการทำงานพร้อมกันใดๆ มาควบคุมเพื่อให้แน่ใจว่าการปรับเปลี่ยนค่านับจะไม่ถูกขัดจังหวะโดยเธรดอื่น ซึ่งอาจส่งผลให้การนับจำนวนคลาดเคลื่อน—กลายเป็นบั๊กที่แอบแฝงและอาจนำไปสู่ปัญหาหน่วยความจำรั่วไหล (memory leak) หรือทำให้ค่าถูกทำลายไปก่อนที่เราจะใช้งานเสร็จ สิ่งที่เราต้องการอย่างแท้จริงคือชนิดข้อมูลที่ทำงานเหมือน Rc<T> ทุกประการ แต่ปรับเปลี่ยนจำนวนเรเฟอเรนซ์ด้วยวิธีการที่ปลอดภัยต่อเธรด (thread-safe)
การนับจำนวนเรเฟอเรนซ์แบบอะตอมมิกด้วย Arc<T>
โชคดีที่ Arc<T> คือ_ชนิดข้อมูลลักษณะเดียวกับ Rc<T> ที่ปลอดภัยต่อการใช้งานในสถานการณ์การทำงานพร้อมกัน ตัวอักษร a นั้นย่อมาจาก atomic ซึ่งหมายความว่าเป็นชนิดข้อมูลที่_นับจำนวนเรเฟอเรนซ์แบบอะตอมมิก (atomically reference-counted) ทั้งนี้ อะตอมมิก (atomic) เป็นพริมิทีฟการทำงานพร้อมกันอีกรูปแบบหนึ่งที่เราจะไม่ลงลึกในรายละเอียดที่นี่ หากสนใจโปรดดูเอกสารของไลบรารีมาตรฐานสำหรับ std::sync::atomic เพิ่มเติม ณ จุดนี้ คุณเพียงแค่ต้องรู้ว่าการทำงานแบบอะตอมมิกนั้นทำหน้าที่คล้ายกับชนิดข้อมูลพื้นฐานทั่วไป แต่ปลอดภัยสำหรับการแชร์ข้ามเธรด
คุณอาจสงสัยว่าแล้วทำไมชนิดข้อมูลพื้นฐานทั้งหมดจึงไม่ถูกทำเป็นแบบอะตอมมิกไปเสียเลย และทำไมชนิดข้อมูลในไลบรารีมาตรฐานถึงไม่ถูกสร้างให้ใช้ Arc<T> เป็นค่าเริ่มต้น เหตุผลก็คือความปลอดภัยต่อเธรดนั้นมีต้นทุนด้านประสิทธิภาพ (performance penalty) แลกมาด้วย ซึ่งเป็นต้นทุนที่คุณควรจ่ายเฉพาะเมื่อจำเป็นต้องใช้จริงๆ เท่านั้น หากคุณเพียงแค่จัดการค่าต่างๆ ภายในเธรดเดียว โค้ดของคุณจะทำงานได้เร็วกว่าหากไม่ต้องแบกรับการบังคับใช้มาตรการความปลอดภัยที่อะตอมมิกจัดเตรียมไว้
คราวนี้กลับมาที่ตัวอย่างของเรา: เนื่องจาก Arc<T> และ Rc<T> มี API เหมือนกันทุกประการ เราจึงแก้โปรแกรมได้ง่ายๆ เพียงเปลี่ยนบรรทัด use, การเรียก new และการเรียก clone แล้วโค้ดในลิสติ้ง 16-15 ก็จะคอมไพล์และรันได้สำเร็จในที่สุด
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!("Result: {}", *counter.lock().unwrap());
}
โค้ดนี้จะพิมพ์สิ่งต่อไปนี้:
Result: 10
เราทำสำเร็จแล้ว! เราสามารถนับค่าจาก 0 ไปถึง 10 ได้สำเร็จ แม้ตัวอย่างนี้อาจดูเรียบง่าย แต่ก็ได้สอนอะไรมากมายเกี่ยวกับ Mutex<T> และความปลอดภัยของเธรด คุณยังสามารถนำโครงสร้างของโปรแกรมนี้ไปประยุกต์ใช้กับงานที่ซับซ้อนกว่าการเพิ่มค่าตัวนับได้อีกด้วย ด้วยแนวทางนี้ คุณสามารถแบ่งการคำนวณออกเป็นส่วนๆ ที่เป็นอิสระต่อกัน แล้วกระจายงานเหล่านั้นไปให้เธรดต่างๆ ทำ จากนั้นจึงใช้ Mutex<T> เพื่อให้แต่ละเธรดเข้ามาอัปเดตผลลัพธ์สุดท้ายในส่วนของตน
ข้อสังเกตคือ หากคุณต้องการเพียงแค่ดำเนินการทางคณิตศาสตร์กับตัวเลขอย่างง่าย ในมอดูล std::sync::atomic ของไลบรารีมาตรฐาน ยังมีชนิดข้อมูลที่เรียบง่ายกว่า Mutex<T> ให้เลือกใช้อีกด้วย ซึ่งชนิดข้อมูลเหล่านั้นช่วยให้เข้าถึงชนิดข้อมูลพื้นฐานได้อย่างปลอดภัย พร้อมกัน และเป็นแบบอะตอมมิก แต่ที่เราเลือกใช้ Mutex<T> กับชนิดข้อมูลพื้นฐานในตัวอย่างนี้ ก็เพื่อให้เราสามารถโฟกัสไปที่กลไกการทำงานของ Mutex<T> ได้อย่างชัดเจน
การเปรียบเทียบ RefCell<T>/Rc<T> กับ Mutex<T>/Arc<T>
คุณอาจสังเกตเห็นว่า counter เป็นตัวแปรที่เปลี่ยนแปลงค่าไม่ได้ แต่เรากลับได้รับเรเฟอเรนซ์แบบเปลี่ยนแปลงค่าได้ไปยังข้อมูลข้างใน นั่นหมายความว่า Mutex<T> มอบความสามารถในการเปลี่ยนแปลงค่าภายใน (interior mutability) ให้เช่นเดียวกับที่ตระกูล Cell ทำ และในทำนองเดียวกับที่เราใช้ RefCell<T> ในบทที่ 15 เพื่อให้สามารถแก้ไขข้อมูลภายใน Rc<T> ได้ เราจึงใช้ Mutex<T> เพื่อแก้ไขข้อมูลภายใน Arc<T> นั่นเอง
รายละเอียดอีกประการที่พึงระวังคือ Rust ไม่สามารถป้องกันข้อผิดพลาดทางตรรกะ (logic error) ได้ทุกรูปแบบเมื่อคุณใช้งาน Mutex<T> หากยังจำได้จากบทที่ 15 การใช้ Rc<T> มีความเสี่ยงที่จะเกิดวงจรเรเฟอเรนซ์ (reference cycle) ที่ค่า Rc<T> สองตัวชี้อ้างอิงถึงกันจนทำให้หน่วยความจำรั่วไหล ในทำนองเดียวกัน Mutex<T> ก็มาพร้อมกับความเสี่ยงที่จะเกิด_เดดล็อก (deadlock)_ ซึ่งจะเกิดขึ้นเมื่อการทำงานหนึ่งจำเป็นต้องล็อกทรัพยากรสองชิ้นพร้อมกัน และมีเธรดสองตัวถือครองล็อกไปคนละชิ้น ทำให้ต่างฝ่ายต่างรอคอยกันไปตลอดกาล หากคุณสนใจศึกษาเรื่องเดดล็อกเพิ่มเติม ลองเขียนโปรแกรม Rust ที่ทำให้เกิดเดดล็อกขึ้นมาดู จากนั้นค้นคว้ากลยุทธ์การป้องกันและบรรเทาปัญหาเดดล็อกสำหรับมิวเท็กซ์ในภาษาใดก็ได้ แล้วลองนำมาอิมพลีเมนต์ใน Rust ซึ่งเอกสาร API ของไลบรารีมาตรฐานสำหรับ Mutex<T> และ MutexGuard มีข้อมูลที่เป็นประโยชน์อย่างยิ่ง
เราจะปิดท้ายบทนี้ด้วยการกล่าวถึงเทรต Send และ Sync รวมถึงวิธีนำพวกมันไปประยุกต์ใช้กับชนิดข้อมูลที่เราสร้างขึ้นเอง