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

การทำงานพร้อมกันแบบใช้สถานะร่วมกัน

การส่งผ่านข้อความ (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) ข้อมูลที่มันเก็บรักษาไว้ผ่านระบบล็อก

มิวเท็กซ์ขึ้นชื่อเรื่องความยุ่งยากในการใช้งาน เพราะคุณต้องจำกฎเหล็กสองข้อนี้ให้ดี:

  1. คุณต้องพยายามขอถือครองล็อกก่อนจะนำข้อมูลไปใช้งาน
  2. เมื่อคุณใช้งานข้อมูลที่มิวเท็กซ์เฝ้าปกป้องเสร็จเรียบร้อยแล้ว คุณต้องปลดล็อกข้อมูลเพื่อให้เธรดอื่นสามารถเข้ามาถือครองล็อกได้

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

การจัดการมิวเท็กซ์ให้ถูกต้องสมบูรณ์นั้นอาจซับซ้อนอย่างเหลือเชื่อ ซึ่งเป็นเหตุผลที่หลายคนชื่นชอบแชนเนลมาก อย่างไรก็ตาม ต้องขอบคุณระบบชนิดข้อมูลและกฎความเป็นเจ้าของของ 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 รวมถึงวิธีนำพวกมันไปประยุกต์ใช้กับชนิดข้อมูลที่เราสร้างขึ้นเอง