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

การทำงานพร้อมกันแบบขยายได้ด้วย Send และ Sync

สิ่งที่น่าสนใจคือ ฟีเจอร์ด้านการทำงานพร้อมกัน (concurrency) เกือบทั้งหมดที่เราได้พูดถึงในบทนี้จนถึงปัจจุบัน ล้วนเป็นส่วนหนึ่งของไลบรารีมาตรฐาน ไม่ได้ฝังแน่นอยู่ในตัวภาษา ทางเลือกของคุณในการจัดการกับการทำงานพร้อมกันจึงไม่ได้จำกัดอยู่เพียงแค่สิ่งที่ตัวภาษาหรือไลบรารีมาตรฐานจัดเตรียมไว้ให้เท่านั้น แต่คุณยังสามารถเขียนฟีเจอร์การทำงานพร้อมกันขึ้นมาเอง หรือนำฟีเจอร์ที่ผู้อื่นเขียนไว้มาใช้งานได้อีกด้วย

อย่างไรก็ดี ท่ามกลางแนวคิดสำคัญด้านการทำงานพร้อมกันที่ฝังลึกอยู่ในตัวภาษาโดยตรง ไม่ใช่ในไลบรารีมาตรฐาน ก็คือมาร์กเกอร์เทรต (marker trait) ใน std::marker อย่าง Send และ Sync

การถ่ายโอนความเป็นเจ้าของระหว่างเธรด

มาร์กเกอร์เทรต Send บ่งชี้ว่า ค่าของชนิดข้อมูลที่อิมพลีเมนต์ Send สามารถถ่ายโอนสิทธิ์ความเป็นเจ้าของ (ownership) ข้ามระหว่างเธรดได้ ชนิดข้อมูลในภาษา Rust เกือบทุกชนิดต่างอิมพลีเมนต์ Send แต่ก็มีข้อยกเว้นบางประการ เช่น Rc<T> ซึ่งไม่สามารถอิมพลีเมนต์ Send ได้ เพราะหากคุณโคลนค่า Rc<T> แล้วพยายามถ่ายโอนความเป็นเจ้าของของตัวโคลนนั้นไปยังอีกเธรดหนึ่ง ทั้งสองเธรดอาจพยายามเข้าไปอัปเดตตัวนับเรเฟอเรนซ์พร้อมๆ กัน ด้วยเหตุนี้ Rc<T> จึงถูกออกแบบมาสำหรับใช้งานในสถานการณ์แบบเธรดเดียว (single-threaded) ที่คุณไม่ต้องการแบกรับต้นทุนด้านประสิทธิภาพเพื่อแลกกับความปลอดภัยของเธรด

ดังนั้น ระบบชนิดข้อมูลและข้อกำหนดเทรต (trait bounds) ของ Rust จึงช่วยรับประกันว่า คุณจะไม่มีทางเผลอส่งค่า Rc<T> ข้ามเธรดอย่างไม่ปลอดภัยโดยไม่ตั้งใจเด็ดขาด ตอนที่เราพยายามทำเช่นนั้นในลิสติ้ง 16-14 เราจึงพบข้อผิดพลาดว่า the trait `Send` is not implemented for `Rc<Mutex<i32>>` และเมื่อเราเปลี่ยนมาใช้ Arc<T> ซึ่งอิมพลีเมนต์ Send โค้ดก็สามารถคอมไพล์ผ่านได้ในที่สุด

ชนิดข้อมูลใดๆ ก็ตามที่ประกอบขึ้นจากสมาชิกที่เป็นชนิดข้อมูลแบบ Send ทั้งหมด จะได้รับการมาร์ก (mark) ว่าเป็น Send โดยอัตโนมัติเช่นกัน ชนิดข้อมูลพื้นฐาน (primitive types) แทบทั้งหมดล้วนเป็น Send ยกเว้นแต่รอว์พอยน์เตอร์ (raw pointer) ซึ่งเราจะได้กล่าวถึงกันในบทที่ 20

การเข้าถึงจากหลายเธรด

มาร์กเกอร์เทรต Sync บ่งชี้ว่า ชนิดข้อมูลที่อิมพลีเมนต์ Sync นั้นปลอดภัยที่จะถูกอ้างอิง (reference) จากหลายๆ เธรดพร้อมกัน กล่าวอีกนัยหนึ่งคือ ชนิดข้อมูล T ใดๆ จะถือว่าอิมพลีเมนต์ Sync ก็ต่อเมื่อ &T (เรเฟอเรนซ์แบบเปลี่ยนแปลงค่าไม่ได้ไปยัง T) อิมพลีเมนต์ Send ซึ่งหมายความว่าเรเฟอเรนซ์ดังกล่าวสามารถส่งต่อไปยังอีกเธรดหนึ่งได้อย่างปลอดภัย เช่นเดียวกับ Send ชนิดข้อมูลพื้นฐานเกือบทั้งหมดต่างอิมพลีเมนต์ Sync และชนิดข้อมูลใดที่ประกอบขึ้นจากสมาชิกที่อิมพลีเมนต์ Sync ทั้งหมด ก็จะอิมพลีเมนต์ Sync ไปด้วยโดยอัตโนมัติ

สมาร์ตพอยน์เตอร์ Rc<T> ไม่ได้อิมพลีเมนต์ Sync ด้วยเหตุผลเดียวกับที่มันไม่อิมพลีเมนต์ Send ส่วนชนิดข้อมูล RefCell<T> (ที่เราได้เรียนรู้กันในบทที่ 15) ตลอดจนตระกูลของชนิดข้อมูล Cell<T> ที่เกี่ยวข้อง ก็ไม่อิมพลีเมนต์ Sync เช่นกัน เนื่องจากการตรวจสอบการยืมที่ RefCell<T> ทำในตอนรันไทม์นั้นไม่ได้ปลอดภัยต่อเธรด แต่สมาร์ตพอยน์เตอร์ Mutex<T> นั้นอิมพลีเมนต์ Sync และสามารถนำไปใช้แชร์การเข้าถึงข้อมูลร่วมกันระหว่างหลายๆ เธรดได้ ดังที่คุณได้เห็นใน“การเข้าถึง Mutex<T> ร่วมกัน”

การอิมพลีเมนต์ Send และ Sync ด้วยตัวเองนั้นเป็น unsafe

เนื่องจากชนิดข้อมูลใดๆ ที่ประกอบขึ้นจากชนิดข้อมูลอื่นที่อิมพลีเมนต์เทรต Send และ Sync อยู่แล้ว จะอิมพลีเมนต์ Send และ Sync ให้โดยอัตโนมัติ เราจึงแทบไม่จำเป็นต้องอิมพลีเมนต์เทรตเหล่านี้ด้วยตนเองเลย และในฐานะที่เป็นมาร์กเกอร์เทรต พวกมันจึงไม่มีเมธอดใดๆ ให้ต้องอิมพลีเมนต์แม้แต่อย่างเดียว ประโยชน์ของพวกมันมีไว้เพื่อบังคับใช้เงื่อนไขคงตัว (invariants) ที่เกี่ยวข้องกับความปลอดภัยในการทำงานพร้อมกันเท่านั้น

การลงมืออิมพลีเมนต์เทรตเหล่านี้ด้วยตนเองจำเป็นต้องเขียนโค้ด Rust ที่ไม่ปลอดภัย (unsafe code) ซึ่งเราจะได้กล่าวถึงการใช้โค้ด unsafe ในบทที่ 20 แต่สำหรับตอนนี้ ประเด็นสำคัญคือการสร้างชนิดข้อมูลสำหรับการทำงานพร้อมกันแบบใหม่ที่ไม่ได้ประกอบขึ้นจากส่วนที่เป็น Send และ Sync นั้น จำเป็นต้องพิจารณาอย่างรอบคอบเป็นพิเศษเพื่อรักษาข้อกำหนดการรับประกันความปลอดภัยเอาไว้ โดย “The Rustonomicon” มีข้อมูลเพิ่มเติมเกี่ยวกับเงื่อนไขการรับประกันเหล่านี้และวิธีปฏิบัติเพื่อรักษาความปลอดภัยดังกล่าว

สรุป

นี่ไม่ใช่ครั้งสุดท้ายที่คุณจะได้พบกับเรื่องการทำงานพร้อมกันในหนังสือเล่มนี้: บทถัดไปจะมุ่งเน้นไปที่การเขียนโปรแกรมแบบอะซิงโครนัส (async programming) และโปรเจกต์ในบทที่ 21 จะนำแนวคิดจากบทนี้ไปประยุกต์ใช้ในสถานการณ์จริงที่สมบูรณ์ยิ่งกว่าตัวอย่างสั้นๆ ที่เราได้เห็นกันไป

ดังที่กล่าวไว้ในตอนต้น เนื่องจากกลไกการจัดการการทำงานพร้อมกันของ Rust มีเพียงส่วนน้อยนิดเท่านั้นที่ฝังอยู่ในตัวภาษา โซลูชันด้านการทำงานพร้อมกันจำนวนมากจึงถูกพัฒนาขึ้นในรูปของเครตภายนอก เครตเหล่านี้มักมีการพัฒนาและปรับปรุงที่รวดเร็วกว่าไลบรารีมาตรฐาน ดังนั้นอย่าลืมค้นคว้าทางออนไลน์เพื่อเลือกใช้เครตที่มีความทันสมัยและเป็นที่ยอมรับในการพัฒนาโปรแกรมแบบมัลติเธรด

ไลบรารีมาตรฐานของ Rust มีทั้งแชนเนล (channel) สำหรับการส่งผ่านข้อความ ตลอดจนชนิดข้อมูลสมาร์ตพอยน์เตอร์อย่าง Mutex<T> และ Arc<T> ซึ่งปลอดภัยต่อการใช้งานในบริบทของการทำงานพร้อมกัน ระบบชนิดข้อมูลและตัวตรวจสอบการยืม (borrow checker) จะช่วยรับประกันว่า โค้ดที่ใช้เครื่องมือเหล่านี้จะไม่เกิดปัญหาการแย่งชิงข้อมูล (data race) หรือมีเรเฟอเรนซ์ที่ไม่ถูกต้องหลุดรอดไปได้ เมื่อใดที่คุณทำให้โค้ดคอมไพล์ผ่าน คุณก็สามารถวางใจได้ว่ามันจะทำงานบนหลายๆ เธรดได้อย่างราบรื่น โดยปราศจากบั๊กแฝงเร้นที่ตามรอยได้ยากดังที่มักพบในภาษาอื่นๆ การเขียนโปรแกรมให้ทำงานพร้อมกันจึงไม่ใช่เรื่องที่น่าหวาดกลัวอีกต่อไป จงก้าวออกไปเขียนโปรแกรมที่ทำงานพร้อมกันได้อย่างมั่นใจและไร้ความกลัว!