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

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

ลิสต์แบบเชื่อมโยงที่ติดป้าย 'a' ชี้ไปยังสมาชิกสามตัว สมาชิกตัวแรกบรรจุจำนวนเต็ม 5 และชี้ไปยังสมาชิกตัวที่สอง สมาชิกตัวที่สองบรรจุจำนวนเต็ม 10 และชี้ไปยังสมาชิกตัวที่สาม สมาชิกตัวที่สามบรรจุค่า 'Nil' ซึ่งบ่งบอกจุดสิ้นสุดของลิสต์ มันไม่ชี้ไปที่ใดเลย ลิสต์แบบเชื่อมโยงที่ติดป้าย 'b' ชี้ไปยังสมาชิกที่บรรจุจำนวนเต็ม 3 และชี้ไปยังสมาชิกตัวแรกของลิสต์ 'a' ลิสต์แบบเชื่อมโยงที่ติดป้าย 'c' ชี้ไปยังสมาชิกที่บรรจุจำนวนเต็ม 4 และยังชี้ไปยังสมาชิกตัวแรกของลิสต์ 'a' ด้วย ส่วนท้ายของลิสต์ 'b' และ 'c' จึงเป็นลิสต์ 'a' ทั้งคู่

รูปที่ 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> เพื่อก้าวข้ามข้อจำกัดเรื่องการไม่สามารถแก้ไขค่านี้ได้