Rc<T> สมาร์ตพอยน์เตอร์แบบนับจำนวนเรเฟอเรนซ์
ในกรณีส่วนใหญ่ ความเป็นเจ้าของ (ownership) มีความชัดเจน กล่าวคือคุณจะรู้ได้อย่างแน่ชัดว่าตัวแปรใดเป็นเจ้าของค่าข้อมูลนั้น ๆ อย่างไรก็ตาม มีบางกรณีที่ค่าข้อมูลเพียงค่าเดียวอาจมีเจ้าของหลายรายพร้อมกันได้ ตัวอย่างเช่น ในโครงสร้างข้อมูลแบบกราฟ เส้นเชื่อมหลายเส้นอาจชี้ไปยังโหนดเดียวกัน และในทางมโนทัศน์แล้ว โหนดดังกล่าวจะถือว่าถูกครอบครองโดยเส้นเชื่อมทั้งหมดที่ชี้มายังมัน ดังนั้นโหนดจึงไม่ควรถูกทำลายหรือเก็บกวาด เว้นแต่ว่าจะไม่มีเส้นเชื่อมใด ๆ ชี้มายังมันอีกแล้ว และกลายเป็นโหนดที่ไม่มีเจ้าของหลงเหลืออยู่
คุณจำเป็นต้องเปิดใช้งานการเป็นเจ้าของร่วมหลายรายอย่างชัดแจ้ง โดยใช้ชนิดข้อมูล Rc<T> ของ Rust ซึ่งย่อมาจาก การนับจำนวนการอ้างอิง (reference counting) ชนิดข้อมูล Rc<T> จะคอยติดตามจำนวนเรเฟอเรนซ์ที่ชี้ไปยังค่าหนึ่ง ๆ เพื่อตรวจสอบว่าค่านั้นยังถูกใช้งานอยู่หรือไม่ หากไม่มีเรเฟอเรนซ์ใดชี้ไปยังค่านั้นแล้ว (จำนวนการอ้างอิงเป็นศูนย์) ค่านั้นก็จะถูกคืนหน่วยความจำและเก็บกวาดให้โดยอัตโนมัติ โดยไม่ส่งผลให้เรเฟอเรนซ์ใด ๆ กลายเป็นเรเฟอเรนซ์ที่ไม่ถูกต้อง
ลองจินตนาการว่า Rc<T> เปรียบเสมือนโทรทัศน์ในห้องนั่งเล่นของครอบครัว เมื่อมีคนแรกเดินเข้ามาดูทีวี เขาก็จะเปิดมันขึ้นมา คนอื่น ๆ ก็สามารถเดินเข้ามาในห้องและร่วมดูทีวีเครื่องเดียวกันได้ และเมื่อคนสุดท้ายเดินออกจากห้องไป เขาก็จะปิดทีวีเพราะไม่มีใครดูอีกแล้ว หากมีใครไปปิดทีวีในขณะที่คนอื่น ๆ ยังคงนั่งดูอยู่ ก็ย่อมเกิดเสียงโวยวายจากผู้ชมที่เหลืออย่างแน่นอน!
เราเลือกใช้ชนิดข้อมูล Rc<T> เมื่อเราต้องการจัดสรรข้อมูลไว้บนฮีปเพื่อให้หลายส่วนของโปรแกรมสามารถอ่านได้ร่วมกัน และเราไม่สามารถระบุได้ตั้งแต่ตอนคอมไพล์ว่าส่วนใดจะเลิกใช้งานข้อมูลนั้นเป็นส่วนสุดท้าย หากเราทราบแน่ชัดว่าส่วนใดจะทำงานเสร็จสิ้นเป็นลำดับสุดท้าย เราก็เพียงแค่กำหนดให้ส่วนนั้นเป็นเจ้าของข้อมูล และให้กฎความเป็นเจ้าของตามปกติที่ตรวจสอบในขณะคอมไพล์ทำงานไปตามเดิม
โปรดทราบว่า Rc<T> มีไว้สำหรับใช้งานในบริบทแบบเธรดเดียว (single-threaded) เท่านั้น เมื่อเราพูดถึงการทำงานพร้อมกัน (concurrency) ในบทที่ 16 เราจะได้เรียนรู้วิธีการนับจำนวนการอ้างอิงในโปรแกรมที่ทำงานแบบหลายเธรด
การแชร์ข้อมูล
ลองกลับมาดูตัวอย่าง cons list ในลิสติ้ง 15-5 กันอีกครั้ง จำได้ไหมว่าเราเคยนิยามมันโดยใช้ Box<T> คราวนี้เราจะสร้างลิสต์สองชุดที่แชร์ความเป็นเจ้าของลิสต์ชุดที่สามร่วมกัน ในเชิงมโนทัศน์แล้ว โครงสร้างนี้จะมีหน้าตาคล้ายกับรูปที่ 15-3
รูปที่ 15-3: ลิสต์สองลิสต์ คือ b และ c ที่แชร์ความเป็นเจ้าของลิสต์ที่สามคือ a
เราจะสร้างลิสต์ a ที่เก็บค่า 5 แล้วตามด้วย 10 จากนั้นเราจะสร้างลิสต์ขึ้นมาอีกสองชุด ได้แก่ b ที่เริ่มต้นด้วย 3 และ c ที่เริ่มต้นด้วย 4 โดยทั้งลิสต์ b และ c จะเชื่อมต่อไปยังลิสต์ a แรกที่เก็บ 5 และ 10 กล่าวอีกนัยหนึ่งก็คือ ทั้งสองลิสต์จะแชร์ลิสต์ตัวแรกที่เก็บค่า 5 และ 10 ร่วมกัน
การพยายามอิมพลีเมนต์สถานการณ์นี้โดยใช้นิยาม List ของเรากับ Box<T> จะใช้ไม่ได้ ดังที่แสดงในลิสติ้ง 15-17
enum List {
Cons(i32, Box<List>),
Nil,
}
use crate::List::{Cons, Nil};
fn main() {
let a = Cons(5, Box::new(Cons(10, Box::new(Nil))));
let b = Cons(3, Box::new(a));
let c = Cons(4, Box::new(a));
}
เมื่อเราคอมไพล์โค้ดนี้ เราจะได้ข้อผิดพลาดนี้:
$ cargo run
Compiling cons-list v0.1.0 (file:///projects/cons-list)
error[E0382]: use of moved value: `a`
--> src/main.rs:11:30
|
9 | let a = Cons(5, Box::new(Cons(10, Box::new(Nil))));
| - move occurs because `a` has type `List`, which does not implement the `Copy` trait
10 | let b = Cons(3, Box::new(a));
| - value moved here
11 | let c = Cons(4, Box::new(a));
| ^ value used here after move
|
note: if `List` implemented `Clone`, you could clone the value
--> src/main.rs:1:1
|
1 | enum List {
| ^^^^^^^^^ consider implementing `Clone` for this type
...
10 | let b = Cons(3, Box::new(a));
| - you could clone this value
For more information about this error, try `rustc --explain E0382`.
error: could not compile `cons-list` (bin "cons-list") due to 1 previous error
วาเรียนต์ Cons เป็นเจ้าของข้อมูลที่มันบรรจุอยู่ ดังนั้นเมื่อเราสร้างลิสต์ b ค่า a จึงถูกย้าย (move) เข้าไปอยู่ใน b และ b จะกลายเป็นเจ้าของ a จากนั้น เมื่อเราพยายามนำ a กลับมาใช้อีกครั้งตอนสร้าง c คอมไพเลอร์จึงไม่อนุญาตเนื่องจาก a ถูกย้ายไปเรียบร้อยแล้ว
เราอาจปรับเปลี่ยนนิยามของ Cons ให้เก็บเรเฟอเรนซ์แทนได้ แต่ก็จะต้องระบุพารามิเตอร์ไลฟ์ไทม์ (lifetime parameters) เพิ่มเติม ซึ่งการระบุพารามิเตอร์ไลฟ์ไทม์จะเป็นการบังคับว่าทุก ๆ สมาชิกในลิสต์จะต้องมีช่วงชีวิตยืนยาวอย่างน้อยเท่ากับลิสต์ทั้งชุด แม้ว่าในลิสติ้ง 15-17 สมาชิกและลิสต์จะมีอายุยืนยาวเช่นนั้นจริง แต่มันก็ไม่ได้เป็นเช่นนั้นเสมอไปในทุกสถานการณ์
แต่เราจะเปลี่ยนนิยามของ List ให้มาใช้ Rc<T> แทน Box<T> ดังที่แสดงในลิสติ้ง 15-18 โดยในตอนนี้วาเรียนต์ Cons แต่ละตัวจะเก็บค่าข้อมูลหนึ่งค่าและ Rc<T> ที่ชี้ไปยัง List และเมื่อเราสร้าง b แทนที่จะเป็นการยึดครองสิทธิ์ความเป็นเจ้าของของ a เราจะทำการโคลน (clone) ตัว Rc<List> ที่ a ถืออยู่ ซึ่งการทำเช่นนี้จะเพิ่มจำนวนการอ้างอิงจากหนึ่งเป็นสอง และเปิดให้ทั้ง a และ b แชร์ความเป็นเจ้าของข้อมูลใน Rc<List> นั้นร่วมกัน นอกจากนี้เรายังโคลน a อีกครั้งตอนสร้าง c ซึ่งจะเพิ่มจำนวนการอ้างอิงจากสองเป็นสาม ทุกครั้งที่เราเรียกใช้ Rc::clone จำนวนการอ้างอิงของข้อมูลภายใน Rc<List> จะเพิ่มขึ้นทีละหนึ่ง และข้อมูลนั้นจะไม่มีทางถูกคืนหน่วยความจำ เว้นแต่ว่าจำนวนการอ้างอิงจะลดลงจนเหลือศูนย์
enum List {
Cons(i32, Rc<List>),
Nil,
}
use crate::List::{Cons, Nil};
use std::rc::Rc;
fn main() {
let a = Rc::new(Cons(5, Rc::new(Cons(10, Rc::new(Nil)))));
let b = Cons(3, Rc::clone(&a));
let c = Cons(4, Rc::clone(&a));
}
เราจำเป็นต้องเพิ่มคำสั่ง use เพื่อนำ Rc<T> เข้าสู่ขอบเขตการทำงาน เนื่องจากมันไม่ได้รวมอยู่ในพรีลูด (prelude) ในฟังก์ชัน main เราสร้างลิสต์ที่เก็บ 5 และ 10 แล้วจัดเก็บไว้ใน Rc<List> ตัวใหม่ในตัวแปร a จากนั้นเมื่อเราสร้าง b และ c เราจะเรียกฟังก์ชัน Rc::clone โดยส่งเรเฟอเรนซ์ที่ชี้ไปยัง Rc<List> ใน a เข้าไปเป็นอาร์กิวเมนต์
จริง ๆ แล้วเราสามารถเขียน a.clone() แทน Rc::clone(&a) ได้ แต่ธรรมเนียมปฏิบัติของชาว Rust คือการใช้ Rc::clone ในกรณีเช่นนี้ เนื่องจากการอิมพลีเมนต์ของ Rc::clone ไม่ได้ทำการคัดลอกข้อมูลทั้งหมดอย่างลึกซึ้ง (deep copy) เหมือนที่การอิมพลีเมนต์ clone ของชนิดข้อมูลส่วนใหญ่ทำ การเรียก Rc::clone ทำหน้าที่เพียงแค่เพิ่มตัวเลขนับจำนวนการอ้างอิงเท่านั้น ซึ่งใช้เวลาในการทำงานน้อยมาก ในขณะที่การทำ deep copy อาจใช้เวลาและทรัพยากรสูง การใช้ Rc::clone สำหรับการนับจำนวนการอ้างอิงจึงช่วยให้เราแยกแยะความแตกต่างระหว่างการโคลนแบบคัดลอกข้อมูลทั้งหมด กับการโคลนเพื่อเพิ่มตัวนับการอ้างอิงได้อย่างชัดเจน เมื่อเราตรวจสอบโค้ดเพื่อหาคอขวดด้านประสิทธิภาพ เราจึงพิจารณาเฉพาะการโคลนแบบ deep copy และสามารถมองข้ามการเรียก Rc::clone ไปได้เลย
การโคลนเพื่อเพิ่มจำนวนเรเฟอเรนซ์
ลองมาปรับเปลี่ยนโค้ดตัวอย่างในลิสติ้ง 15-18 เพื่อให้เราเห็นการเปลี่ยนแปลงของจำนวนการอ้างอิงอย่างชัดเจน ในขณะที่เราสร้างและทิ้ง (drop) การอ้างอิงไปยัง Rc<List> ใน a
ในลิสติ้ง 15-19 เราจะแก้ไขฟังก์ชัน main โดยสร้างขอบเขตชั้นใน (inner scope) ครอบตัวแปรลิสต์ c เอาไว้ เพื่อให้เห็นว่าจำนวนการอ้างอิงเปลี่ยนแปลงไปอย่างไรเมื่อ c หลุดออกจากขอบเขต
enum List {
Cons(i32, Rc<List>),
Nil,
}
use crate::List::{Cons, Nil};
use std::rc::Rc;
// --snip--
fn main() {
let a = Rc::new(Cons(5, Rc::new(Cons(10, Rc::new(Nil)))));
println!("count after creating a = {}", Rc::strong_count(&a));
let b = Cons(3, Rc::clone(&a));
println!("count after creating b = {}", Rc::strong_count(&a));
{
let c = Cons(4, Rc::clone(&a));
println!("count after creating c = {}", Rc::strong_count(&a));
}
println!("count after c goes out of scope = {}", Rc::strong_count(&a));
}
ในแต่ละจุดของโปรแกรมที่มีการเปลี่ยนแปลงจำนวนการอ้างอิง เราจะพิมพ์จำนวนการอ้างอิงออกมา ซึ่งได้มาจากการเรียกฟังก์ชัน Rc::strong_count สาเหตุที่ฟังก์ชันนี้ใช้ชื่อว่า strong_count แทนที่จะเป็น count ธรรมดา ก็เพราะชนิดข้อมูล Rc<T> ยังมีฟังก์ชัน weak_count อยู่อีกตัวหนึ่งด้วย ซึ่งเราจะได้เห็นว่า weak_count นำไปใช้งานอย่างไรในหัวข้อ “การป้องกันวงจรเรเฟอเรนซ์ด้วย Weak<T>”
โค้ดนี้พิมพ์ผลลัพธ์ต่อไปนี้:
$ cargo run
Compiling cons-list v0.1.0 (file:///projects/cons-list)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.45s
Running `target/debug/cons-list`
count after creating a = 1
count after creating b = 2
count after creating c = 3
count after c goes out of scope = 2
เราจะเห็นว่า Rc<List> ใน a เริ่มต้นด้วยจำนวนการอ้างอิงเท่ากับ 1 จากนั้นทุกครั้งที่เราเรียก clone จำนวนนับก็จะเพิ่มขึ้นทีละ 1 และเมื่อ c หลุดออกจากขอบเขต จำนวนนับก็จะลดลง 1 เราไม่จำเป็นต้องเรียกใช้ฟังก์ชันเพื่อลดจำนวนการอ้างอิงเหมือนอย่างที่เราต้องเรียก Rc::clone เพื่อเพิ่มจำนวนนับ เนื่องจากการอิมพลีเมนต์เทรต Drop จะช่วยลดจำนวนการอ้างอิงให้โดยอัตโนมัติเมื่อค่า Rc<T> หลุดออกจากขอบเขต
สิ่งที่ไม่ได้แสดงให้เห็นในเอาต์พุตของตัวอย่างนี้ก็คือ เมื่อ b และตามด้วย a หลุดออกจากขอบเขตเมื่อสิ้นสุดฟังก์ชัน main จำนวนการอ้างอิงจะกลายเป็น 0 และ Rc<List> ก็จะถูกคืนหน่วยความจำและเก็บกวาดไปอย่างสมบูรณ์ การใช้ Rc<T> ช่วยให้ค่าข้อมูลค่าเดียวสามารถมีเจ้าของหลายรายได้ และตัวนับการอ้างอิงนี้จะคอยรับประกันว่าค่านั้นจะยังคงใช้งานได้อยู่เสมอ ตราบใดที่ยังมีเจ้าของรายใดรายหนึ่งยังคงอยู่
การแชร์ข้อมูลผ่าน Rc<T> นั้นเป็นการแชร์ข้อมูลผ่านเรเฟอเรนซ์แบบแก้ไขไม่ได้ (immutable reference) ซึ่งเปิดให้หลายส่วนของโปรแกรมอ่านข้อมูลร่วมกันได้เท่านั้น หาก Rc<T> อนุญาตให้เรามีเรเฟอเรนซ์แบบแก้ไขได้หลายตัวพร้อมกัน ก็อาจจะละเมิดกฎการยืมข้อสำคัญที่เราพูดถึงในบทที่ 4 ซึ่งระบุว่า การยืมแบบแก้ไขได้หลายจุดในตำแหน่งเดียวกันอาจทำให้เกิดการแย่งชิงข้อมูล (data race) และความไม่สอดคล้องกันของข้อมูลได้ แต่ความสามารถในการแก้ไขข้อมูลได้นั้นมีประโยชน์อย่างยิ่ง! ในหัวข้อถัดไป เราจะมาพูดคุยกันถึงรูปแบบความสามารถในการเปลี่ยนแปลงค่าภายใน (interior mutability) และชนิดข้อมูล RefCell<T> ซึ่งคุณสามารถนำมาใช้งานร่วมกับ Rc<T> เพื่อก้าวข้ามข้อจำกัดเรื่องการไม่สามารถแก้ไขค่านี้ได้