รันโค้ดเมื่อทำความสะอาดด้วยเทรต Drop
เทรตที่สองที่มีความสำคัญต่อรูปแบบสมาร์ตพอยน์เตอร์ก็คือ Drop ซึ่งช่วยให้คุณสามารถกำหนดพฤติกรรมที่จะเกิดขึ้นเมื่อค่าของตัวแปรหนึ่งกำลังจะหลุดออกจากขอบเขต (scope) ได้ คุณสามารถอิมพลีเมนต์เทรต Drop ให้กับชนิดข้อมูลใดก็ได้ และโค้ดดังกล่าวมักถูกนำมาใช้เพื่อปลดปล่อยและคืนทรัพยากรต่าง ๆ เช่น ไฟล์ หรือการเชื่อมต่อเครือข่าย
เราแนะนำเทรต Drop ในบริบทของสมาร์ตพอยน์เตอร์ เพราะการทำงานของเทรตนี้ถูกนำมาใช้อยู่เสมอในการสร้างสมาร์ตพอยน์เตอร์ ตัวอย่างเช่น เมื่อ Box<T> ถูกทิ้ง (drop) ตัวมันเองก็จะคืนพื้นที่หน่วยความจำบนฮีปที่บ็อกซ์นั้นชี้อยู่ให้โดยอัตโนมัติ
ในบางภาษาและกับชนิดข้อมูลบางประเภท โปรแกรมเมอร์จะต้องเรียกใช้คำสั่งเพื่อคืนหน่วยความจำหรือทรัพยากรด้วยตนเองทุกครั้งที่ใช้งานอินสแตนซ์เหล่านั้นเสร็จสิ้น เช่น ตัวจัดการไฟล์ (file handles), ซ็อกเก็ต (sockets) หรือล็อก (locks) หากโปรแกรมเมอร์ลืม ระบบก็อาจทำงานหนักเกินไปจนเกิดการล่ม (crash) ได้ แต่ใน Rust คุณสามารถกำหนดโค้ดเฉพาะเจาะจงให้ทำงานโดยอัตโนมัติเมื่อใดก็ตามที่ค่านั้นหลุดออกจากขอบเขต โดยที่คอมไพเลอร์จะเป็นผู้แทรกโค้ดนี้ให้เอง ส่งผลให้คุณไม่ต้องคอยกังวลกับการวางโค้ดเก็บกวาดทรัพยากรไว้ทุกหนทุกแห่งในโปรแกรมหลังจากเลิกใช้งานอินสแตนซ์ของชนิดข้อมูลนั้น ๆ โดยไม่มีการรั่วไหลของทรัพยากรเกิดขึ้นเลย!
คุณสามารถกำหนดโค้ดที่จะให้ทำงานเมื่อค่าหลุดออกจากขอบเขตได้ด้วยการอิมพลีเมนต์เทรต Drop โดยเทรต Drop กำหนดให้คุณต้องอิมพลีเมนต์เมธอดหนึ่งตัวชื่อ drop ซึ่งรับพารามิเตอร์เป็นเรเฟอเรนซ์แบบเปลี่ยนแปลงได้ที่ชี้ไปยัง self เพื่อให้เห็นภาพชัดเจนว่า Rust เรียกใช้งาน drop เมื่อใด เราจะมาลองเขียนเมธอด drop โดยใส่คำสั่ง println! ไว้ในเบื้องต้นกันก่อน
ลิสติ้ง 15-14 แสดง struct CustomSmartPointer ที่มีฟังก์ชันการทำงานกำหนดเองเพียงอย่างเดียวคือมันจะพิมพ์ Dropping CustomSmartPointer! เมื่ออินสแตนซ์ออกจากสโคป เพื่อแสดงว่า Rust รันเมธอด drop เมื่อใด
struct CustomSmartPointer {
data: String,
}
impl Drop for CustomSmartPointer {
fn drop(&mut self) {
println!("Dropping CustomSmartPointer with data `{}`!", self.data);
}
}
fn main() {
let c = CustomSmartPointer {
data: String::from("my stuff"),
};
let d = CustomSmartPointer {
data: String::from("other stuff"),
};
println!("CustomSmartPointers created");
}
เนื่องจากเทรต Drop ถูกรวมไว้ในพรีลูด (prelude) อยู่แล้ว เราจึงไม่จำเป็นต้องนำเข้าสู่ขอบเขตด้วยตนเอง เราอิมพลีเมนต์เทรต Drop ให้กับ CustomSmartPointer และเขียนการทำงานของเมธอด drop ให้เรียกใช้ println! โดยเนื้อหาภายในเมธอด drop นี้คือจุดที่คุณสามารถใส่ตรรกะใด ๆ ก็ตามที่ต้องการให้ทำงานเมื่ออินสแตนซ์ของชนิดข้อมูลของคุณหลุดออกจากขอบเขต ในตัวอย่างนี้เราพิมพ์ข้อความออกมาเพื่อให้เห็นภาพชัดเจนว่า Rust เรียกใช้ drop ในจังหวะใด
ในฟังก์ชัน main เราสร้างอินสแตนซ์ของ CustomSmartPointer ขึ้นมาสองตัว จากนั้นจึงพิมพ์ข้อความ CustomSmartPointers created เมื่อสิ้นสุดฟังก์ชัน main อินสแตนซ์ของ CustomSmartPointer จะหลุดออกจากขอบเขต และ Rust ก็จะเรียกโค้ดที่เราใส่ไว้ในเมธอด drop ซึ่งจะพิมพ์ข้อความปิดท้ายของเราออกมา โปรดสังเกตว่าเราไม่จำเป็นต้องเรียกเมธอด drop ด้วยตนเองอย่างโจ่งแจ้งเลย
เมื่อเรารันโปรแกรมนี้ เราจะเห็นผลลัพธ์ต่อไปนี้:
$ cargo run
Compiling drop-example v0.1.0 (file:///projects/drop-example)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.60s
Running `target/debug/drop-example`
CustomSmartPointers created
Dropping CustomSmartPointer with data `other stuff`!
Dropping CustomSmartPointer with data `my stuff`!
Rust ได้เรียกใช้ drop ให้เราโดยอัตโนมัติเมื่ออินสแตนซ์หลุดออกจากขอบเขต โดยรันโค้ดตามที่เรากำหนดไว้ ตัวแปรต่าง ๆ จะถูกทิ้งตามลำดับย้อนกลับจากการสร้าง ดังนั้น d จึงถูกทิ้งก่อน c จุดประสงค์ของตัวอย่างนี้คือการแสดงให้เห็นภาพการทำงานของเมธอด drop อย่างเป็นรูปธรรม ซึ่งในการใช้งานจริงคุณจะใส่โค้ดสำหรับเก็บกวาดทรัพยากรที่จำเป็น แทนที่จะเป็นเพียงการพิมพ์ข้อความ
ทว่าการปิดใช้งานการทำงานอัตโนมัติของ drop นั้นไม่ใช่เรื่องที่จะทำได้โดยตรง ซึ่งโดยปกติแล้วการปิดการทำงานของ drop ก็ไม่มีความจำเป็นอยู่แล้ว เพราะจุดประสงค์หลักของเทรต Drop คือการดูแลเรื่องนี้ให้โดยอัตโนมัติ อย่างไรก็ตาม ในบางครั้งคุณอาจจำเป็นต้องเก็บกวาดค่าใดค่าหนึ่งก่อนเวลาอันควร ตัวอย่างเช่น การใช้สมาร์ตพอยน์เตอร์ที่คอยจัดการล็อก (locks) คุณอาจต้องการบังคับให้เมธอด drop ปลดล็อกทันที เพื่อให้โค้ดส่วนอื่นในขอบเขตเดียวกันสามารถเข้าถือครองล็อกต่อไปได้ Rust จะไม่อนุญาตให้คุณเรียกเมธอด drop ของเทรต Drop ด้วยตนเอง แต่คุณจะต้องเรียกใช้ฟังก์ชัน std::mem::drop ที่ไลบรารีมาตรฐานจัดเตรียมไว้ให้แทน หากคุณต้องการบังคับให้ค่านั้นถูกทิ้งก่อนที่จะสิ้นสุดขอบเขตของมัน
การพยายามเรียกเมธอด drop ของเทรต Drop ด้วยตัวเองโดยการแก้ไขฟังก์ชัน main จากลิสติ้ง 15-14 จะไม่ทำงาน ดังที่แสดงในลิสติ้ง 15-15
struct CustomSmartPointer {
data: String,
}
impl Drop for CustomSmartPointer {
fn drop(&mut self) {
println!("Dropping CustomSmartPointer with data `{}`!", self.data);
}
}
fn main() {
let c = CustomSmartPointer {
data: String::from("some data"),
};
println!("CustomSmartPointer created");
c.drop();
println!("CustomSmartPointer dropped before the end of main");
}
เมื่อเราพยายามคอมไพล์โค้ดนี้ เราจะได้ข้อผิดพลาดนี้:
$ cargo run
Compiling drop-example v0.1.0 (file:///projects/drop-example)
error[E0040]: explicit use of destructor method
--> src/main.rs:16:7
|
16 | c.drop();
| ^^^^ explicit destructor calls not allowed
|
help: consider using `drop` function
|
16 - c.drop();
16 + drop(c);
|
For more information about this error, try `rustc --explain E0040`.
error: could not compile `drop-example` (bin "drop-example") due to 1 previous error
ข้อความแสดงข้อผิดพลาดนี้ระบุชัดเจนว่าเราไม่ได้รับอนุญาตให้เรียกใช้ drop อย่างโจ่งแจ้งด้วยตนเอง โดยข้อความนี้ใช้คำว่า destructor ซึ่งเป็นคำศัพท์ทั่วไปในการเขียนโปรแกรมสำหรับฟังก์ชันที่ทำหน้าที่เก็บกวาดทำลายอินสแตนซ์ คำว่า destructor เปรียบได้กับคู่ตรงข้ามของ constructor ที่ทำหน้าที่สร้างอินสแตนซ์ขึ้นมา โดยฟังก์ชัน drop ใน Rust ก็จัดเป็น destructor รูปแบบหนึ่งนั่นเอง
สาเหตุที่ Rust ไม่อนุญาตให้เราเรียกใช้ drop ด้วยตนเอง ก็เพราะ Rust จะยังคงเรียกใช้ drop กับค่านั้นโดยอัตโนมัติเมื่อสิ้นสุดฟังก์ชัน main อยู่ดี ซึ่งจะนำไปสู่ข้อผิดพลาด double free (การพยายามปลดปล่อยหน่วยความจำซ้ำซ้อน) เนื่องจาก Rust พยายามจะเก็บกวาดค่าเดิมถึงสองครั้ง
ในเมื่อเราไม่สามารถปิดการแทรกคำสั่ง drop อัตโนมัติเมื่อค่าหลุดออกจากขอบเขตได้ และไม่สามารถเรียกเมธอด drop ด้วยตนเองได้ ดังนั้นหากเราจำเป็นต้องบังคับให้เก็บกวาดค่าหนึ่งก่อนเวลาจริง ๆ เราจึงต้องใช้งานฟังก์ชัน std::mem::drop
ฟังก์ชัน std::mem::drop แตกต่างจากเมธอด drop ในเทรต Drop เราเรียกมันโดยส่งค่าที่ต้องการบังคับให้ทิ้งเป็นอาร์กิวเมนต์ ฟังก์ชันนี้อยู่ในพรีลูด เราจึงแก้ไข main ในลิสติ้ง 15-15 ให้เรียกฟังก์ชัน drop ได้ ดังที่แสดงในลิสติ้ง 15-16
struct CustomSmartPointer {
data: String,
}
impl Drop for CustomSmartPointer {
fn drop(&mut self) {
println!("Dropping CustomSmartPointer with data `{}`!", self.data);
}
}
fn main() {
let c = CustomSmartPointer {
data: String::from("some data"),
};
println!("CustomSmartPointer created");
drop(c);
println!("CustomSmartPointer dropped before the end of main");
}
การรันโค้ดนี้จะพิมพ์ผลลัพธ์ต่อไปนี้:
$ cargo run
Compiling drop-example v0.1.0 (file:///projects/drop-example)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.73s
Running `target/debug/drop-example`
CustomSmartPointer created
Dropping CustomSmartPointer with data `some data`!
CustomSmartPointer dropped before the end of main
ข้อความ Dropping CustomSmartPointer with data `some data`! ถูกพิมพ์คั่นอยู่ระหว่างข้อความ CustomSmartPointer created และ CustomSmartPointer dropped before the end of main ซึ่งแสดงให้เห็นว่าโค้ดของเมธอด drop ถูกเรียกเพื่อทิ้งค่า c ณ ตำแหน่งนั้นทันที
คุณสามารถนำโค้ดที่กำหนดไว้ในการอิมพลีเมนต์เทรต Drop ไปประยุกต์ใช้งานได้หลากหลายรูปแบบ เพื่อให้การเก็บกวาดทรัพยากรทำได้อย่างสะดวกและปลอดภัย ตัวอย่างเช่น คุณอาจใช้มันเพื่อสร้างตัวจัดสรรหน่วยความจำ (memory allocator) ขึ้นมาใช้เอง! ด้วยเทรต Drop ร่วมกับระบบความเป็นเจ้าของ (ownership) ของ Rust คุณจึงไม่ต้องคอยจำว่าต้องเก็บกวาดทรัพยากรเมื่อใด เพราะ Rust จะจัดการทุกอย่างให้โดยอัตโนมัติ
นอกจากนี้ คุณยังไม่ต้องกังวลกับปัญหาที่เกิดจากการเผลอไปเก็บกวาดค่าที่ยังถูกใช้งานอยู่ เพราะระบบความเป็นเจ้าของที่คอยดูแลให้เรเฟอเรนซ์มีความถูกต้องสมบูรณ์อยู่เสมอนั้น ยังรับประกันด้วยว่า drop จะถูกเรียกเพียงครั้งเดียวเมื่อค่านั้นไม่มีการใช้งานอีกต่อไปแล้วเท่านั้น
หลังจากที่เราได้ศึกษา Box<T> และคุณลักษณะสำคัญของสมาร์ตพอยน์เตอร์ไปแล้ว ต่อไปเรามาดูสมาร์ตพอยน์เตอร์ตัวอื่น ๆ ที่น่าสนใจในไลบรารีมาตรฐานกันต่อ