RefCell<T> และแพตเทิร์นการเปลี่ยนแปลงค่าภายใน
ความสามารถในการเปลี่ยนแปลงค่าภายใน (interior mutability) เป็นรูปแบบการออกแบบ (design pattern) ใน Rust ที่ช่วยให้คุณสามารถแก้ไขข้อมูลได้ แม้ว่าจะมีเรเฟอเรนซ์แบบแก้ไขไม่ได้ (immutable references) ชี้ไปยังข้อมูลนั้นอยู่ก็ตาม ซึ่งตามปกติแล้วการกระทำเช่นนี้จะถูกห้ามโดยกฎการยืม ในการแก้ไขข้อมูล รูปแบบนี้จะใช้โค้ด unsafe ภายในโครงสร้างข้อมูลเพื่อผ่อนปรนกฎเกณฑ์ตามปกติของ Rust ที่ควบคุมการแก้ไขข้อมูลและการยืม โค้ด unsafe จะเป็นการส่งสัญญาณบอกคอมไพเลอร์ว่าเรากำลังตรวจสอบกฎเกณฑ์ต่าง ๆ ด้วยตนเอง แทนที่จะพึ่งพาให้คอมไพเลอร์ตรวจสอบให้เรา โดยเราจะพูดถึงโค้ด unsafe กันอย่างละเอียดมากขึ้นในบทที่ 20
เราสามารถเลือกใช้ชนิดข้อมูลที่ใช้รูปแบบการเปลี่ยนแปลงค่าภายในได้ ก็ต่อเมื่อเรามั่นใจได้ว่ากฎการยืมจะได้รับการปฏิบัติตามอย่างถูกต้องในขณะรันไทม์ แม้ว่าคอมไพเลอร์จะไม่สามารถรับประกันสิ่งนั้นในขณะคอมไพล์ได้ก็ตาม โดยโค้ด unsafe ที่เกี่ยวข้องจะถูกห่อหุ้มไว้ภายใน API ที่ปลอดภัย ทำให้ชนิดข้อมูลภายนอกยังคงมีสถานะเป็นชนิดข้อมูลที่แก้ไขไม่ได้ตามปกติ
เรามาลองสำรวจแนวคิดนี้ผ่านชนิดข้อมูล RefCell<T> ซึ่งนำรูปแบบการเปลี่ยนแปลงค่าภายในมาใช้งานกัน
การบังคับใช้กฎการยืมตอนรันไทม์
สิ่งที่ต่างจาก Rc<T> คือ ชนิดข้อมูล RefCell<T> แสดงถึงความเป็นเจ้าของเพียงรายเดียว (single ownership) เหนือข้อมูลที่มันถืออยู่ แล้วอะไรที่ทำให้ RefCell<T> แตกต่างจากชนิดข้อมูลอย่าง Box<T>? ลองนึกย้อนกลับไปถึงกฎการยืมที่คุณได้เรียนรู้ในบทที่ 4:
- ในเวลาใดเวลาหนึ่ง คุณสามารถมีเรเฟอเรนซ์แบบแก้ไขได้เพียงหนึ่งตัว หรือ เรเฟอเรนซ์แบบแก้ไขไม่ได้กี่ตัวก็ได้ (แต่ต้องไม่ใช่ทั้งสองแบบพร้อมกัน)
- เรเฟอเรนซ์ต้องถูกต้องและชี้ไปยังข้อมูลที่ยังมีอยู่เสมอ (valid)
สำหรับเรเฟอเรนซ์ทั่วไปและ Box<T> เงื่อนไขคงที่ (invariants) ของกฎการยืมจะถูกบังคับใช้ตั้งแต่ตอนคอมไพล์ แต่สำหรับ RefCell<T> เงื่อนไขเหล่านี้จะถูกตรวจสอบและบังคับใช้_ในขณะรันไทม์_ หากคุณละเมิดกฎเหล่านี้เมื่อใช้เรเฟอเรนซ์ทั่วไป คุณจะได้รับข้อผิดพลาดจากคอมไพเลอร์ แต่หากคุณละเมิดกฎเหล่านี้เมื่อใช้ RefCell<T> โปรแกรมของคุณจะแพนิก (panic!) และยุติการทำงานลงทันที
ข้อดีของการตรวจสอบกฎการยืมในขั้นตอนคอมไพล์คือ ข้อผิดพลาดจะถูกตรวจพบได้อย่างรวดเร็วตั้งแต่ในกระบวนการพัฒนา และไม่มีต้นทุนสูญเปล่าด้านประสิทธิภาพในขณะรันไทม์ เพราะการวิเคราะห์ทั้งหมดได้เสร็จสิ้นล่วงหน้าไปแล้ว ด้วยเหตุผลเหล่านี้ การตรวจสอบกฎการยืมตอนคอมไพล์จึงเป็นทางเลือกที่ดีที่สุดในกรณีส่วนใหญ่ และเป็นเหตุผลว่าทำไม Rust จึงกำหนดให้สิ่งนี้เป็นพฤติกรรมเริ่มต้น
ส่วนข้อดีของการตรวจสอบกฎการยืมในขณะรันไทม์ก็คือ มันจะเปิดโอกาสให้สามารถทำบางสิ่งที่ปลอดภัยต่อหน่วยความจำได้ ซึ่งหากเป็นการตรวจสอบในขณะคอมไพล์อาจจะไม่อนุญาต เนื่องจากการวิเคราะห์โค้ดแบบสถิต (static analysis) เช่นเดียวกับที่คอมไพเลอร์ของ Rust ทำนั้น โดยเนื้อแท้แล้วจำเป็นต้องระมัดระวังเป็นพิเศษ (conservative) เพราะมีคุณสมบัติบางประการของโค้ดที่ไม่สามารถตรวจจับได้ผ่านการวิเคราะห์โค้ด ตัวอย่างที่โด่งดังที่สุดคือปัญหาการยุติการทำงาน (Halting Problem) ซึ่งอยู่นอกเหนือขอบเขตของหนังสือเล่มนี้ แต่นับเป็นหัวข้อที่น่าสนใจอย่างยิ่ง
เนื่องจากการวิเคราะห์บางอย่างเป็นไปไม่ได้ในทางทฤษฎี หากคอมไพเลอร์ของ Rust ไม่มั่นใจว่าโค้ดนั้นปฏิบัติตามกฎความเป็นเจ้าของอย่างสมบูรณ์ มันก็อาจจะปฏิเสธโปรแกรมที่เขียนมาอย่างถูกต้องได้ ซึ่งในแง่นี้ถือว่าคอมไพเลอร์เลือกที่จะปลอดภัยไว้ก่อน เพราะหาก Rust ยอมรับโปรแกรมที่มีข้อผิดพลาด ผู้ใช้ก็จะไม่สามารถเชื่อถือการรับประกันความปลอดภัยของ Rust ได้อีกต่อไป ทว่าหาก Rust ปฏิเสธโปรแกรมที่ทำงานถูกต้อง แม้นักพัฒนาจะรู้สึกไม่สะดวกสบาย แต่ก็ไม่มีความเสียหายร้ายแรงใด ๆ เกิดขึ้นกับระบบ ชนิดข้อมูล RefCell<T> จึงมีประโยชน์อย่างยิ่งเมื่อคุณมั่นใจว่าโค้ดของคุณปฏิบัติตามกฎการยืมอย่างแน่นอน แต่คอมไพเลอร์ไม่ฉลาดพอที่จะเข้าใจและรับประกันสิ่งนั้นให้คุณได้
เช่นเดียวกับ Rc<T> ชนิดข้อมูล RefCell<T> มีไว้สำหรับใช้งานในบริบทแบบเธรดเดียว (single-threaded) เท่านั้น และจะเกิดข้อผิดพลาดในการคอมไพล์ทันทีหากคุณพยายามนำมันไปใช้ในงานแบบหลายเธรด โดยเราจะพูดถึงวิธีการนำความสามารถของ RefCell<T> ไปใช้ในโปรแกรมแบบหลายเธรดในบทที่ 16
นี่คือข้อสรุปในการเลือกระหว่าง Box<T>, Rc<T> หรือ RefCell<T>:
Rc<T>เปิดให้ข้อมูลเดียวกันมีเจ้าของได้หลายราย ส่วนBox<T>และRefCell<T>มีเจ้าของได้เพียงรายเดียวBox<T>อนุญาตให้มีการยืมแบบแก้ไขไม่ได้หรือแก้ไขได้ โดยตรวจสอบในขั้นตอนคอมไพล์ ส่วนRc<T>อนุญาตเฉพาะการยืมแบบแก้ไขไม่ได้ที่ตรวจสอบตอนคอมไพล์ และRefCell<T>อนุญาตให้มีการยืมแบบแก้ไขไม่ได้หรือแก้ไขได้ โดยตรวจสอบในขณะรันไทม์- เนื่องจาก
RefCell<T>อนุญาตให้มีการยืมแบบแก้ไขได้ที่ตรวจสอบในขณะรันไทม์ คุณจึงสามารถแก้ไขค่าที่อยู่ภายในRefCell<T>ได้ แม้ว่าตัวแปรRefCell<T>นั้นจะมีสถานะเป็นค่าที่แก้ไขไม่ได้ก็ตาม
การแก้ไขค่าที่อยู่ภายในค่าที่ไม่สามารถแก้ไขได้นี้ก็คือ รูปแบบความสามารถในการเปลี่ยนแปลงค่าภายใน (interior mutability pattern) เรามาดูสถานการณ์ที่รูปแบบนี้มีประโยชน์และศึกษาว่ามันทำงานได้อย่างไร
การใช้การเปลี่ยนแปลงค่าภายใน
ผลสืบเนื่องจากกฎการยืมก็คือ เมื่อคุณมีค่าที่ไม่สามารถแก้ไขได้ คุณจะไม่สามารถขอยืมค่านั้นแบบแก้ไขได้ ตัวอย่างเช่น โค้ดต่อไปนี้จะคอมไพล์ไม่ผ่าน:
fn main() {
let x = 5;
let y = &mut x;
}
หากคุณลองคอมไพล์โค้ดนี้ คุณจะพบกับข้อผิดพลาดต่อไปนี้:
$ cargo run
Compiling borrowing v0.1.0 (file:///projects/borrowing)
error[E0596]: cannot borrow `x` as mutable, as it is not declared as mutable
--> src/main.rs:3:13
|
3 | let y = &mut x;
| ^^^^^^ cannot borrow as mutable
|
help: consider changing this to be mutable
|
2 | let mut x = 5;
| +++
For more information about this error, try `rustc --explain E0596`.
error: could not compile `borrowing` (bin "borrowing") due to 1 previous error
อย่างไรก็ตาม มีบางสถานการณ์ที่จะเป็นประโยชน์อย่างมากหากค่าหนึ่งสามารถปรับปรุงแก้ไขตัวเองภายในเมธอดของมันได้ แต่ยังคงแสดงตัวเป็นค่าที่แก้ไขไม่ได้ต่อโค้ดภายนอก โดยโค้ดภายนอกจะไม่สามารถแก้ไขค่านั้นได้เลย การใช้ RefCell<T> เป็นวิธีหนึ่งที่ช่วยให้ได้มาซึ่งความสามารถในการเปลี่ยนแปลงค่าภายในนี้ แต่ RefCell<T> ก็ไม่ได้หลบเลี่ยงกฎการยืมอย่างสิ้นเชิง ตัวตรวจสอบการยืม (borrow checker) ในคอมไพเลอร์จะยอมผ่อนปรนให้เกิดการเปลี่ยนแปลงค่าภายในได้ และกฎการยืมจะถูกนำไปตรวจสอบในขณะรันไทม์แทน หากคุณละเมิดกฎ คุณจะได้รับคำสั่ง panic! แทนที่จะเป็นข้อผิดพลาดจากคอมไพเลอร์
เรามาลองดูตัวอย่างการใช้งานจริงที่เราสามารถใช้ RefCell<T> เพื่อแก้ไขค่าที่ไม่สามารถแก้ไขได้ และดูว่าทำไมสิ่งนี้จึงมีประโยชน์
การทดสอบด้วยม็อกออบเจกต์
บางครั้งในระหว่างการทดสอบ นักพัฒนามักจะใช้ชนิดข้อมูลจำลองขึ้นมาแทนที่ชนิดข้อมูลจริง เพื่อคอยสังเกตพฤติกรรมเฉพาะเจาะจงและตรวจสอบยืนยันว่าโค้ดได้รับการอิมพลีเมนต์อย่างถูกต้อง ชนิดข้อมูลตัวแทนนี้เรียกว่า ตัวแทนทดสอบ (test double) เปรียบได้กับตัวแสดงแทน (stunt double) ในการถ่ายทำภาพยนตร์ ที่จะมีคนเข้ามาแสดงแทนดารานำในฉากที่ยากหรืออันตรายเป็นพิเศษ ตัวแทนทดสอบจะทำหน้าที่เป็นตัวแสดงแทนให้กับชนิดข้อมูลอื่น ๆ เมื่อเรารันการทดสอบ โดย ม็อกออบเจกต์ (mock object) เป็นชนิดหนึ่งของตัวแทนทดสอบที่คอยบันทึกสิ่งที่เกิดขึ้นระหว่างการทดสอบ เพื่อให้คุณสามารถตรวจสอบยืนยันได้ว่าการทำงานต่าง ๆ เกิดขึ้นอย่างถูกต้องตรงตามที่คาดหมาย
Rust ไม่ได้มีแนวคิดของออบเจกต์ในความหมายเดียวกับที่ภาษาอื่นมี และ Rust ก็ไม่มีฟังก์ชันการทำงานของม็อกออบเจกต์สำเร็จรูปมาให้ในไลบรารีมาตรฐานเหมือนกับบางภาษา อย่างไรก็ตาม คุณสามารถสร้าง struct ขึ้นมาทำหน้าที่เช่นเดียวกับม็อกออบเจกต์ได้อย่างแน่นอน
นี่คือสถานการณ์จำลองที่เราจะใช้ทดสอบ: เราจะสร้างไลบรารีสำหรับติดตามค่าตัวเลขหนึ่งเปรียบเทียบกับค่าสูงสุด และส่งข้อความแจ้งเตือนตามระดับความใกล้ของค่าปัจจุบันเทียบกับค่าสูงสุด ตัวอย่างเช่น ไลบรารีนี้อาจนำไปใช้ติดตามโควตาการเรียกใช้งาน API ของผู้ใช้ที่ได้รับอนุญาต
ไลบรารีของเราจะทำหน้าที่เฉพาะการติดตามดูว่าค่าตัวเลขใกล้ถึงค่าสูงสุดเพียงใด และควรส่งข้อความอะไรในเวลาใด โดยแอปพลิเคชันที่นำไลบรารีของเราไปใช้จะต้องเป็นผู้จัดเตรียมกลไกในการส่งข้อความจริงเอง เช่น แอปพลิเคชันอาจแสดงข้อความบนหน้าจอ, ส่งอีเมล, ส่งข้อความ SMS หรืออื่น ๆ โดยที่ไลบรารีไม่จำเป็นต้องรับรู้รายละเอียดเหล่านั้น สิ่งที่ไลบรารีต้องการมีเพียงแค่บางสิ่งที่อิมพลีเมนต์เทรตที่เราเตรียมไว้ให้ ซึ่งมีชื่อว่า Messenger โดยลิสติ้ง 15-20 แสดงโค้ดของไลบรารีนี้
pub trait Messenger {
fn send(&self, msg: &str);
}
pub struct LimitTracker<'a, T: Messenger> {
messenger: &'a T,
value: usize,
max: usize,
}
impl<'a, T> LimitTracker<'a, T>
where
T: Messenger,
{
pub fn new(messenger: &'a T, max: usize) -> LimitTracker<'a, T> {
LimitTracker {
messenger,
value: 0,
max,
}
}
pub fn set_value(&mut self, value: usize) {
self.value = value;
let percentage_of_max = self.value as f64 / self.max as f64;
if percentage_of_max >= 1.0 {
self.messenger.send("Error: You are over your quota!");
} else if percentage_of_max >= 0.9 {
self.messenger
.send("Urgent warning: You've used up over 90% of your quota!");
} else if percentage_of_max >= 0.75 {
self.messenger
.send("Warning: You've used up over 75% of your quota!");
}
}
}
หัวใจสำคัญส่วนหนึ่งของโค้ดนี้คือ เทรต Messenger จะมีเมธอดหนึ่งตัวชื่อ send ซึ่งรับเรเฟอเรนซ์แบบแก้ไขไม่ได้ที่ชี้ไปยัง self และข้อความที่จะส่ง เทรตนี้ทำหน้าที่เป็นอินเทอร์เฟซที่ม็อกออบเจกต์ของเราต้องอิมพลีเมนต์ เพื่อให้สามารถนำม็อกไปใช้งานได้ในลักษณะเดียวกับออบเจกต์จริง ส่วนสำคัญอีกประการคือ เราต้องการทดสอบพฤติกรรมของเมธอด set_value บน LimitTracker ซึ่งแม้ว่าเราจะสามารถเปลี่ยนค่าตัวเลขที่ส่งเข้าไปในพารามิเตอร์ value ได้ แต่ set_value ก็ไม่ได้ส่งคืนค่าใด ๆ ออกมาให้เราตรวจสอบเงื่อนไข (assertion) ได้โดยตรง สิ่งที่เราต้องการยืนยันก็คือ หากเราสร้าง LimitTracker ขึ้นมาโดยใช้บางสิ่งที่อิมพลีเมนต์เทรต Messenger และระบุค่า max ไว้ เมื่อเราส่งตัวเลข value ในระดับต่าง ๆ เข้าไป ตัวเมสเซนเจอร์จะถูกสั่งให้ส่งข้อความแจ้งเตือนที่ถูกต้องเหมาะสมออกมาหรือไม่
เราจึงต้องการม็อกออบเจกต์ที่เมื่อถูกเรียกใช้เมธอด send แทนที่จะส่งอีเมลหรือข้อความ SMS จริง ๆ มันจะทำเพียงแค่คอยบันทึกข้อความที่ได้รับคำสั่งให้ส่งเอาไว้ เราสามารถสร้างอินสแตนซ์ใหม่ของม็อกออบเจกต์, สร้าง LimitTracker ที่เรียกใช้ม็อกออบเจกต์นั้น, เรียกเมธอด set_value บน LimitTracker แล้วจึงตรวจสอบว่าม็อกออบเจกต์มีข้อความบันทึกไว้ตรงตามที่เราคาดหวังหรือไม่ ลิสติ้ง 15-21 แสดงความพยายามในการสร้างม็อกออบเจกต์ดังกล่าว แต่ตัวตรวจสอบการยืมของ Rust จะไม่อนุญาตให้โค้ดนี้ผ่านได้
pub trait Messenger {
fn send(&self, msg: &str);
}
pub struct LimitTracker<'a, T: Messenger> {
messenger: &'a T,
value: usize,
max: usize,
}
impl<'a, T> LimitTracker<'a, T>
where
T: Messenger,
{
pub fn new(messenger: &'a T, max: usize) -> LimitTracker<'a, T> {
LimitTracker {
messenger,
value: 0,
max,
}
}
pub fn set_value(&mut self, value: usize) {
self.value = value;
let percentage_of_max = self.value as f64 / self.max as f64;
if percentage_of_max >= 1.0 {
self.messenger.send("Error: You are over your quota!");
} else if percentage_of_max >= 0.9 {
self.messenger
.send("Urgent warning: You've used up over 90% of your quota!");
} else if percentage_of_max >= 0.75 {
self.messenger
.send("Warning: You've used up over 75% of your quota!");
}
}
}
#[cfg(test)]
mod tests {
use super::*;
struct MockMessenger {
sent_messages: Vec<String>,
}
impl MockMessenger {
fn new() -> MockMessenger {
MockMessenger {
sent_messages: vec![],
}
}
}
impl Messenger for MockMessenger {
fn send(&self, message: &str) {
self.sent_messages.push(String::from(message));
}
}
#[test]
fn it_sends_an_over_75_percent_warning_message() {
let mock_messenger = MockMessenger::new();
let mut limit_tracker = LimitTracker::new(&mock_messenger, 100);
limit_tracker.set_value(80);
assert_eq!(mock_messenger.sent_messages.len(), 1);
}
}
โค้ดทดสอบนี้กำหนด struct MockMessenger ที่มีฟิลด์ sent_messages เป็นชนิด Vec<String> เพื่อคอยบันทึกข้อความที่ได้รับคำสั่งให้ส่ง นอกจากนี้เรายังนิยามฟังก์ชันที่สัมพันธ์กัน (associated function) new เพื่ออำนวยความสะดวกในการสร้างอินสแตนซ์ของ MockMessenger ใหม่ที่เริ่มต้นด้วยเวกเตอร์ว่างเปล่า จากนั้นเราอิมพลีเมนต์เทรต Messenger ให้กับ MockMessenger เพื่อให้สามารถส่ง MockMessenger ให้กับ LimitTracker ได้ และในการนิยามเมธอด send เรานำข้อความที่ส่งเข้ามาเป็นพารามิเตอร์ไปจัดเก็บไว้ในลิสต์ sent_messages ของ MockMessenger
ในส่วนของการทดสอบ เรากำลังทดสอบสถานการณ์ที่ LimitTracker ได้รับคำสั่งให้ตั้งค่า value เป็นค่าที่มากกว่า 75 เปอร์เซ็นต์ของค่า max ขั้นแรกเราสร้าง MockMessenger ตัวใหม่ขึ้นมา ซึ่งจะเริ่มต้นด้วยรายการข้อความที่ว่างเปล่า จากนั้นเราสร้าง LimitTracker ตัวใหม่โดยส่งเรเฟอเรนซ์ของ MockMessenger ใหม่นั้น และกำหนดค่า max เป็น 100 แล้วจึงเรียกเมธอด set_value บน LimitTracker ด้วยค่า 80 ซึ่งมากกว่า 75 เปอร์เซ็นต์ของ 100 หลังจากนั้นเราทำการยืนยันเงื่อนไข (assert) ว่ารายการข้อความที่ MockMessenger บันทึกไว้นั้นควรจะมีข้อความอยู่หนึ่งข้อความ
อย่างไรก็ตาม เกิดปัญหาขึ้นกับเทสต์นี้ ดังที่แสดงในข้อผิดพลาดต่อไปนี้:
$ cargo test
Compiling limit-tracker v0.1.0 (file:///projects/limit-tracker)
error[E0596]: cannot borrow `self.sent_messages` as mutable, as it is behind a `&` reference
--> src/lib.rs:58:13
|
58 | self.sent_messages.push(String::from(message));
| ^^^^^^^^^^^^^^^^^^ `self` is a `&` reference, so it cannot be borrowed as mutable
|
help: consider changing this to be a mutable reference in the `impl` method and the `trait` definition
|
2 ~ fn send(&mut self, msg: &str);
3 | }
...
56 | impl Messenger for MockMessenger {
57 ~ fn send(&mut self, message: &str) {
|
For more information about this error, try `rustc --explain E0596`.
error: could not compile `limit-tracker` (lib test) due to 1 previous error
เราไม่สามารถแก้ไขข้อมูลใน MockMessenger เพื่อบันทึกข้อความได้ เพราะเมธอด send รับเรเฟอเรนซ์แบบแก้ไขไม่ได้ที่ชี้ไปยัง self และเราก็ไม่สามารถทำตามคำแนะนำของข้อความผิดพลาดที่บอกให้เปลี่ยนไปใช้ &mut self ได้เช่นกัน เพราะนั่นจะต้องเปลี่ยนทั้งในบล็อก impl และในนิยามของเทรต ซึ่งเราไม่ต้องการแก้ไขนิยามของเทรต Messenger เพียงเพื่อการเขียนเทสต์เท่านั้น แต่เราจำเป็นต้องหาวิธีทำให้โค้ดทดสอบทำงานร่วมกับโครงสร้างเดิมที่มีอยู่ให้ได้
นี่แหละคือสถานการณ์ที่ความสามารถในการเปลี่ยนแปลงค่าภายในสามารถช่วยเราได้! โดยเราจะนำ sent_messages ไปเก็บไว้ภายใน RefCell<T> ซึ่งจะทำให้เมธอด send สามารถปรับปรุงแก้ไขข้อมูลใน sent_messages เพื่อบันทึกข้อความที่ได้รับเข้ามาได้ ลิสติ้ง 15-22 แสดงให้เห็นว่าโครงสร้างใหม่นี้มีหน้าตาเป็นอย่างไร
pub trait Messenger {
fn send(&self, msg: &str);
}
pub struct LimitTracker<'a, T: Messenger> {
messenger: &'a T,
value: usize,
max: usize,
}
impl<'a, T> LimitTracker<'a, T>
where
T: Messenger,
{
pub fn new(messenger: &'a T, max: usize) -> LimitTracker<'a, T> {
LimitTracker {
messenger,
value: 0,
max,
}
}
pub fn set_value(&mut self, value: usize) {
self.value = value;
let percentage_of_max = self.value as f64 / self.max as f64;
if percentage_of_max >= 1.0 {
self.messenger.send("Error: You are over your quota!");
} else if percentage_of_max >= 0.9 {
self.messenger
.send("Urgent warning: You've used up over 90% of your quota!");
} else if percentage_of_max >= 0.75 {
self.messenger
.send("Warning: You've used up over 75% of your quota!");
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::cell::RefCell;
struct MockMessenger {
sent_messages: RefCell<Vec<String>>,
}
impl MockMessenger {
fn new() -> MockMessenger {
MockMessenger {
sent_messages: RefCell::new(vec![]),
}
}
}
impl Messenger for MockMessenger {
fn send(&self, message: &str) {
self.sent_messages.borrow_mut().push(String::from(message));
}
}
#[test]
fn it_sends_an_over_75_percent_warning_message() {
// --snip--
let mock_messenger = MockMessenger::new();
let mut limit_tracker = LimitTracker::new(&mock_messenger, 100);
limit_tracker.set_value(80);
assert_eq!(mock_messenger.sent_messages.borrow().len(), 1);
}
}
ตอนนี้ฟิลด์ sent_messages จะเปลี่ยนเป็นชนิด RefCell<Vec<String>> แทนที่จะเป็น Vec<String> และในฟังก์ชัน new เราจะสร้างอินสแตนซ์ของ RefCell<Vec<String>> ครอบเวกเตอร์ที่ว่างเปล่าเอาไว้
สำหรับการอิมพลีเมนต์เมธอด send พารามิเตอร์ตัวแรกยังคงเป็นการยืม self แบบแก้ไขไม่ได้เหมือนเดิม ซึ่งตรงกับนิยามของเทรตทุกประการ แต่เราจะเรียกใช้เมธอด borrow_mut บน RefCell<Vec<String>> ใน self.sent_messages เพื่อขอเรเฟอเรนซ์แบบแก้ไขได้ที่ชี้ไปยังค่าภายใน RefCell<Vec<String>> ซึ่งก็คือเวกเตอร์ จากนั้นเราจึงสามารถเรียกใช้ push บนเรเฟอเรนซ์แบบแก้ไขได้ของเวกเตอร์นั้น เพื่อบันทึกข้อความที่ถูกส่งเข้ามาในระหว่างการทดสอบได้
การเปลี่ยนแปลงจุดสุดท้ายที่เราต้องทำก็คือในขั้นตอนการยืนยันเงื่อนไข (assertion): ในการตรวจสอบจำนวนสมาชิกในเวกเตอร์ภายใน เราจะเรียกใช้เมธอด borrow บน RefCell<Vec<String>> เพื่อขอเรเฟอเรนซ์แบบแก้ไขไม่ได้ที่ชี้ไปยังเวกเตอร์นั้น
เมื่อคุณได้เห็นวิธีการใช้งาน RefCell<T> ไปแล้ว ต่อไปเรามาเจาะลึกกันว่ากลไกการทำงานภายในของมันเป็นอย่างไร!
การติดตามการยืมตอนรันไทม์
เมื่อเราต้องการสร้างเรเฟอเรนซ์แบบแก้ไขไม่ได้และแบบแก้ไขได้ เราจะใช้ไวยากรณ์ & และ &mut ตามลำดับ แต่สำหรับ RefCell<T> เราจะใช้เมธอด borrow และ borrow_mut ซึ่งเป็นส่วนหนึ่งของ API ที่ปลอดภัยของ RefCell<T> โดยเมธอด borrow จะส่งคืนสมาร์ตพอยน์เตอร์ชนิด Ref<T> และ borrow_mut จะส่งคืนสมาร์ตพอยน์เตอร์ชนิด RefMut<T> ซึ่งทั้งสองชนิดต่างอิมพลีเมนต์เทรต Deref จึงทำให้เราสามารถปฏิบัติต่อพวกมันได้เสมือนเป็นเรเฟอเรนซ์ทั่วไป
ตัว RefCell<T> จะคอยติดตามอยู่ตลอดเวลาว่ามีสมาร์ตพอยน์เตอร์ Ref<T> และ RefMut<T> กำลังทำงานอยู่จำนวนเท่าใด ทุกครั้งที่เราเรียกใช้ borrow ทาง RefCell<T> จะเพิ่มตัวนับการยืมแบบแก้ไขไม่ได้ที่กำลังทำงานอยู่ขึ้นหนึ่ง และเมื่อค่า Ref<T> หลุดออกจากขอบเขต ตัวนับการยืมแบบแก้ไขไม่ได้ก็จะลดลงหนึ่ง และเช่นเดียวกับกฎการยืมในขั้นตอนคอมไพล์ RefCell<T> จะอนุญาตให้เรามีการยืมแบบแก้ไขไม่ได้หลายตัวพร้อมกัน หรือมีการยืมแบบแก้ไขได้เพียงตัวเดียว ณ ช่วงเวลาใดเวลาหนึ่งเท่านั้น
หากเราพยายามละเมิดกฎเหล่านี้ แทนที่จะได้รับข้อผิดพลาดจากคอมไพเลอร์เหมือนตอนใช้เรเฟอเรนซ์ทั่วไป ตัว RefCell<T> จะสั่งให้โปรแกรมแพนิก (panic!) ในขณะรันไทม์ทันที ลิสติ้ง 15-23 แสดงการปรับปรุงโค้ดเมธอด send จากลิสติ้ง 15-22 โดยเราจงใจสร้างการยืมแบบแก้ไขได้สองตัวพร้อมกันในขอบเขตเดียวกัน เพื่อแสดงให้เห็นว่า RefCell<T> จะป้องกันไม่ให้เราทำเช่นนั้นในขณะรันไทม์ได้อย่างไร
pub trait Messenger {
fn send(&self, msg: &str);
}
pub struct LimitTracker<'a, T: Messenger> {
messenger: &'a T,
value: usize,
max: usize,
}
impl<'a, T> LimitTracker<'a, T>
where
T: Messenger,
{
pub fn new(messenger: &'a T, max: usize) -> LimitTracker<'a, T> {
LimitTracker {
messenger,
value: 0,
max,
}
}
pub fn set_value(&mut self, value: usize) {
self.value = value;
let percentage_of_max = self.value as f64 / self.max as f64;
if percentage_of_max >= 1.0 {
self.messenger.send("Error: You are over your quota!");
} else if percentage_of_max >= 0.9 {
self.messenger
.send("Urgent warning: You've used up over 90% of your quota!");
} else if percentage_of_max >= 0.75 {
self.messenger
.send("Warning: You've used up over 75% of your quota!");
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::cell::RefCell;
struct MockMessenger {
sent_messages: RefCell<Vec<String>>,
}
impl MockMessenger {
fn new() -> MockMessenger {
MockMessenger {
sent_messages: RefCell::new(vec![]),
}
}
}
impl Messenger for MockMessenger {
fn send(&self, message: &str) {
let mut one_borrow = self.sent_messages.borrow_mut();
let mut two_borrow = self.sent_messages.borrow_mut();
one_borrow.push(String::from(message));
two_borrow.push(String::from(message));
}
}
#[test]
fn it_sends_an_over_75_percent_warning_message() {
let mock_messenger = MockMessenger::new();
let mut limit_tracker = LimitTracker::new(&mock_messenger, 100);
limit_tracker.set_value(80);
assert_eq!(mock_messenger.sent_messages.borrow().len(), 1);
}
}
เราสร้างตัวแปร one_borrow เพื่อเก็บสมาร์ตพอยน์เตอร์ RefMut<T> ที่ได้จาก borrow_mut จากนั้นเราสร้างการยืมแบบแก้ไขได้อีกตัวหนึ่งด้วยวิธีเดียวกันในตัวแปร two_borrow การทำเช่นนี้ทำให้มีเรเฟอเรนซ์แบบแก้ไขได้สองตัวอยู่ในขอบเขตเดียวกัน ซึ่งเป็นสิ่งที่ไม่ได้รับอนุญาต เมื่อเรารันการทดสอบของไลบรารี โค้ดในลิสติ้ง 15-23 จะคอมไพล์ผ่านได้โดยไม่มีข้อผิดพลาดใด ๆ แต่การทดสอบจะล้มเหลว:
$ cargo test
Compiling limit-tracker v0.1.0 (file:///projects/limit-tracker)
Finished `test` profile [unoptimized + debuginfo] target(s) in 0.91s
Running unittests src/lib.rs (target/debug/deps/limit_tracker-e599811fa246dbde)
running 1 test
test tests::it_sends_an_over_75_percent_warning_message ... FAILED
failures:
---- tests::it_sends_an_over_75_percent_warning_message stdout ----
thread 'tests::it_sends_an_over_75_percent_warning_message' (6028024) panicked at src/lib.rs:60:53:
RefCell already borrowed
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
failures:
tests::it_sends_an_over_75_percent_warning_message
test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
error: test failed, to rerun pass `--lib`
โปรดสังเกตว่าโปรแกรมเกิดการแพนิกพร้อมข้อความ already borrowed: BorrowMutError นี่คือกลไกที่ RefCell<T> ใช้จัดการกับการละเมิดกฎการยืมในขณะรันไทม์
การเลือกที่จะตรวจจับข้อผิดพลาดของการยืมในขณะรันไทม์แทนที่จะเป็นตอนคอมไพล์ดังที่เราทำในตัวอย่างนี้ หมายความว่าคุณอาจจะตรวจพบข้อผิดพลาดในโค้ดล่าช้ากว่าเดิมในกระบวนการพัฒนา ซึ่งอาจตรวจไม่พบจนกระทั่งโค้ดถูกนำไปใช้งานจริงบนระบบโปรดักชัน นอกจากนี้ โค้ดของคุณจะต้องแบกรับภาระด้านประสิทธิภาพ (runtime performance penalty) เล็กน้อยจากการที่ต้องคอยติดตามการยืมในขณะรันไทม์ อย่างไรก็ตาม การใช้ RefCell<T> ช่วยให้เราสามารถสร้างม็อกออบเจกต์ที่สามารถแก้ไขข้อมูลตัวเองเพื่อบันทึกข้อความที่ตรวจพบได้ ในขณะที่ตัวมันเองถูกนำไปใช้งานในบริบทที่อนุญาตเฉพาะค่าที่แก้ไขไม่ได้เท่านั้น คุณจึงสามารถเลือกใช้ RefCell<T> แม้จะมีข้อแลกเปลี่ยนเหล่านี้ เพื่อให้ได้มาซึ่งฟังก์ชันการทำงานที่ยืดหยุ่นกว่าที่เรเฟอเรนซ์ทั่วไปมอบให้ได้
การอนุญาตเจ้าของหลายรายของข้อมูลที่เปลี่ยนแปลงได้
วิธีหนึ่งที่นิยมใช้ RefCell<T> กันมากคือการนำไปใช้งานร่วมกับ Rc<T> จำได้ไหมว่า Rc<T> ช่วยให้ข้อมูลชิ้นหนึ่งสามารถมีเจ้าของได้หลายราย แต่จะให้สิทธิ์การเข้าถึงข้อมูลนั้นแบบอ่านได้อย่างเดียว (immutable) เท่านั้น หากคุณมี Rc<T> ที่ถือครอง RefCell<T> อยู่ข้างใน คุณก็จะได้ค่าข้อมูลที่สามารถมีเจ้าของได้หลายราย และ สามารถแก้ไขข้อมูลนั้นได้ด้วยพร้อมกัน!
ตัวอย่างเช่น ลองนึกย้อนกลับไปถึงตัวอย่าง cons list ในลิสติ้ง 15-18 ที่เราใช้ Rc<T> เพื่อให้ลิสต์หลายชุดแชร์ความเป็นเจ้าของลิสต์อีกชุดหนึ่งร่วมกัน เนื่องจาก Rc<T> เก็บได้เฉพาะค่าที่ไม่สามารถแก้ไขได้ เราจึงไม่สามารถเปลี่ยนแปลงค่าใด ๆ ในลิสต์ได้เลยหลังจากสร้างมันขึ้นมาแล้ว คราวนี้เราจะนำ RefCell<T> เข้ามาเสริมเพื่อเพิ่มความสามารถในการแก้ไขค่าในลิสต์ ลิสติ้ง 15-24 แสดงให้เห็นว่าการใช้ RefCell<T> ในนิยามของ Cons ช่วยให้เราสามารถปรับปรุงแก้ไขค่าที่จัดเก็บอยู่ในลิสต์ทั้งหมดได้
#[derive(Debug)]
enum List {
Cons(Rc<RefCell<i32>>, Rc<List>),
Nil,
}
use crate::List::{Cons, Nil};
use std::cell::RefCell;
use std::rc::Rc;
fn main() {
let value = Rc::new(RefCell::new(5));
let a = Rc::new(Cons(Rc::clone(&value), Rc::new(Nil)));
let b = Cons(Rc::new(RefCell::new(3)), Rc::clone(&a));
let c = Cons(Rc::new(RefCell::new(4)), Rc::clone(&a));
*value.borrow_mut() += 10;
println!("a after = {a:?}");
println!("b after = {b:?}");
println!("c after = {c:?}");
}
เราสร้างค่าอินสแตนซ์ของ Rc<RefCell<i32>> แล้วเก็บไว้ในตัวแปรชื่อ value เพื่อให้เราสามารถเข้าถึงมันได้โดยตรงในภายหลัง จากนั้นเราสร้าง List ในตัวแปร a ด้วยวาเรียนต์ Cons ที่ถือครอง value ไว้ โดยเราจำเป็นต้องทำการโคลน value เพื่อให้ทั้ง a และ value ต่างมีสิทธิ์ความเป็นเจ้าของในค่า 5 ที่อยู่ภายใน แทนที่จะเป็นการโอนย้ายสิทธิ์ความเป็นเจ้าของจาก value ไปให้ a หรือให้ a ยืมจาก value
เราห่อหุ้มลิสต์ a ไว้ใน Rc<T> เพื่อให้เมื่อเราสร้างลิสต์ b และ c ทั้งสองลิสต์จะสามารถอ้างอิงมายัง a ได้ เช่นเดียวกับที่เราเคยทำในลิสติ้ง 15-18
หลังจากที่เราสร้างลิสต์ใน a, b และ c เรียบร้อยแล้ว เราต้องการบวก 10 เพิ่มเข้าไปในค่าของ value เราทำสิ่งนี้ได้โดยการเรียก borrow_mut บน value ซึ่งจะใช้ฟีเจอร์การดีเรเฟอเรนซ์อัตโนมัติ (automatic dereferencing) ที่เราเคยพูดถึงในหัวข้อ “ตัวดำเนินการ -> อยู่ที่ไหน?” ในบทที่ 5 เพื่อทำการดีเรเฟอเรนซ์ Rc<T> ไปยังค่า RefCell<T> ที่อยู่ภายใน เมธอด borrow_mut จะส่งคืนสมาร์ตพอยน์เตอร์ RefMut<T> ออกมา แล้วเราจึงใช้ตัวดำเนินการดีเรเฟอเรนซ์กับมันเพื่อแก้ไขค่าที่อยู่ข้างใน
เมื่อเราพิมพ์ค่าของ a, b และ c ออกมาดู เราจะพบว่าทั้งหมดมีค่าที่ได้รับการแก้ไขเป็น 15 แทนที่จะเป็น 5 ตามเดิม:
$ cargo run
Compiling cons-list v0.1.0 (file:///projects/cons-list)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.63s
Running `target/debug/cons-list`
a after = Cons(RefCell { value: 15 }, Nil)
b after = Cons(RefCell { value: 3 }, Cons(RefCell { value: 15 }, Nil))
c after = Cons(RefCell { value: 4 }, Cons(RefCell { value: 15 }, Nil))
เทคนิคนี้ยอดเยี่ยมมาก! การใช้ RefCell<T> ช่วยให้เรามีค่า List ที่ภายนอกดูเหมือนแก้ไขไม่ได้ แต่เราสามารถเรียกใช้เมธอดบน RefCell<T> ที่เปิดทางให้เข้าถึงความสามารถในการเปลี่ยนแปลงค่าภายใน เพื่อแก้ไขข้อมูลตามที่ต้องการได้ การตรวจสอบกฎการยืมในขณะรันไทม์ช่วยปกป้องเราจากการแย่งชิงข้อมูล (data race) และในบางครั้งการยอมแลกความเร็วเล็กน้อยเพื่อให้ได้มาซึ่งความยืดหยุ่นของโครงสร้างข้อมูลเช่นนี้ก็ถือว่าคุ้มค่ามาก อย่างไรก็ตาม โปรดทราบว่า RefCell<T> ไม่สามารถใช้งานร่วมกับโค้ดที่ทำงานแบบหลายเธรดได้! โดยชนิดข้อมูล Mutex<T> จะเป็นเวอร์ชันที่ปลอดภัยต่อเธรด (thread-safe) ของ RefCell<T> ซึ่งเราจะได้พูดคุยกันถึง Mutex<T> ในบทที่ 16