Learn Rust Coding · บทเรียน

ตัวชี้อัจฉริยะ Box, Rc และ Arc

ทำความเข้าใจวิธีที่ `Box` สำหรับการจัดสรรบนฮีป `Rc` สำหรับความเป็นเจ้าของร่วม และ `Arc` สำหรับความเป็นเจ้าของร่วมที่ปลอดภัยต่อเธรด ใช้จัดการข้อมูล

ตัวชี้อัจฉริยะ Box, Rc และ Arc เป็นบทเรียน Learn Rust Coding ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 3 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Learn Rust Coding และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Learn Rust Coding มีบทเรียนทั้งหมด 3 บทเรียน

พอยน์เตอร์อัจฉริยะคืออะไร

ระบบความเป็นเจ้าของของ Rust ยอดเยี่ยมสำหรับความปลอดภัยของหน่วยความจำ แต่บางครั้งคุณก็ต้องการความยืดหยุ่นมากขึ้น นั่นคือจุดที่ พอยน์เตอร์อัจฉริยะ เข้ามาช่วย

พอยน์เตอร์อัจฉริยะคือโครงสร้างข้อมูลที่ทำหน้าที่คล้ายพอยน์เตอร์ แต่มีข้อมูลเมทาดาทาและความสามารถเพิ่มเติมด้วย โดยจัดการหน่วยความจำ ความเป็นเจ้าของ และทรัพยากรอื่น ๆ ให้โดยอัตโนมัติ

Box: การจัดเก็บข้อมูลบนฮีป

พอยน์เตอร์อัจฉริยะที่ง่ายที่สุดคือ Box<T> ซึ่งช่วยให้คุณจัดเก็บข้อมูลบน ฮีป แทนสแตก

สแตก: ข้อมูลขนาดคงที่และทำงานได้รวดเร็ว
ฮีป: ข้อมูลขนาดยืดหยุ่นที่ช้ากว่าและจัดสรรขณะโปรแกรมทำงาน

เมื่อคุณใส่ค่าไว้ใน Box ตัว Box เองจะอยู่บนสแตก แต่ข้อมูลที่มันชี้ไปจะอยู่บนฮีป

การใช้ Box เพื่อจัดสรรข้อมูลบนฮีป

มาดูกันว่า Box ย้ายข้อมูลไปยังฮีปอย่างไร วิธีนี้มีประโยชน์สำหรับข้อมูลขนาดใหญ่หรือกรณีที่คุณไม่ทราบขนาดขณะคอมไพล์

เรียกใช้โค้ดนี้เพื่อสังเกตค่าที่ถูกใส่ไว้ใน Box

fn main() {
  let x = 5; // x is on the stack
  let boxed_x = Box::new(x); // x's value is moved to the heap, boxed_x is on stack
  println!("Value on stack: {}", x);
  println!("Value in Box (on heap): {}", *boxed_x); // Dereference to get value
}

เมื่อใดจึงควรใช้ Box

คุณอาจใช้ Box<T> ในสถานการณ์ต่อไปนี้

เมื่อคุณมีชนิดข้อมูลที่ไม่สามารถทราบขนาดขณะคอมไพล์ และจำเป็นต้องจัดเก็บไว้ในตำแหน่งที่มีขนาดคงที่และทราบแน่นอน
เมื่อคุณมีข้อมูลจำนวนมากและต้องการโอนความเป็นเจ้าของโดยไม่คัดลอกตัวข้อมูล
เมื่อคุณต้องการเป็นเจ้าของออบเจ็กต์ของเทรต เช่น Box<dyn Trait>

Rc: เจ้าของหลายราย (เธรดเดียว)

กฎความเป็นเจ้าของของ Rust หมายความว่าโดยปกติค่าหนึ่งค่าจะมีเจ้าของเพียงรายเดียว แต่ถ้าหลายส่วนของโปรแกรมต้องการ “เป็นเจ้าของ” ข้อมูลเดียวกันล่ะ

Rc<T> หรือ การนับจำนวนการอ้างอิง ช่วยให้ข้อมูลมีเจ้าของหลายรายในกรณีที่มี เธรดเดียว โดยจะติดตามจำนวนการอ้างอิงที่ชี้ไปยังข้อมูลนั้น

เมื่อจำนวนลดลงเหลือศูนย์ ข้อมูลจะถูกล้างออก

การแบ่งปันข้อมูลด้วย Rc

Rc::clone() จะเพิ่มจำนวนการอ้างอิง วิธีนี้ไม่ใช่การคัดลอกข้อมูลทั้งหมด แต่เป็นเพียงการสร้างพอยน์เตอร์อีกตัวที่ชี้ไปยังข้อมูลเดียวกัน

สังเกตว่าข้อมูลถูกแบ่งปัน และสามารถเข้าถึงค่าได้จาก “เจ้าของ” ต่างรายกัน

use std::rc::Rc;

fn main() {
  let value = Rc::new(String::from("Shared String"));
  println!("Count after creation: {}", Rc::strong_count(&value));

  let value_clone_a = Rc::clone(&value); // Increment count
  println!("Count after clone A: {}", Rc::strong_count(&value));

  {
    let value_clone_b = Rc::clone(&value); // Increment count
    println!("Count after clone B: {}", Rc::strong_count(&value));
    println!("Data from A: {}", value_clone_a);
    println!("Data from B: {}", value_clone_b);
  } // value_clone_b goes out of scope, count decreases

  println!("Count after B goes out of scope: {}", Rc::strong_count(&value));
}

Arc: ความเป็นเจ้าของร่วมกัน (หลายเธรด)

Rc<T> ทำงานได้ดีในแอปพลิเคชันที่มีเธรดเดียว อย่างไรก็ตาม หากคุณต้องการแบ่งปันข้อมูลระหว่าง เธรด หลายเธรด Rc<T> จะไม่ปลอดภัย

Arc<T> หรือ การนับจำนวนการอ้างอิงแบบอะตอมิก เป็นรุ่นของ Rc<T> ที่ปลอดภัยสำหรับเธรด โดยใช้การดำเนินการแบบอะตอมิกเพื่อปรับปรุงจำนวนการอ้างอิง จึงรับรองความปลอดภัยระหว่างเธรด

Arc มีค่าใช้จ่ายด้านประสิทธิภาพเล็กน้อยเมื่อเทียบกับ Rc เนื่องจากการดำเนินการแบบอะตอมิก

การแบ่งปันข้อมูลระหว่างเธรดด้วย Arc

ตัวอย่างนี้แสดงให้เห็นว่า Arc ช่วยให้หลายเธรดเข้าถึงและอ่านข้อมูลที่แบ่งปันเดียวกันได้อย่างปลอดภัยอย่างไร แต่ละเธรดจะมีสำเนา `Arc` ของตัวเอง

เธรดหลักจะรอให้เธรดที่สร้างขึ้นทั้งหมดทำงานเสร็จ

use std::sync::Arc;
use std::thread;

fn main() {
  let data = Arc::new(vec![1, 2, 3, 4, 5]);
  let mut handles = vec![];

  for i in 0..3 {
    let data_clone = Arc::clone(&data); // Clone Arc for each thread
    let handle = thread::spawn(move || {
      println!("Thread {} has data: {:?}", i, *data_clone);
    });
    handles.push(handle);
  }

  for handle in handles {
    handle.join().unwrap();
  }
  println!("All threads finished.");
}

Box, Rc หรือ Arc

การเลือกพอยน์เตอร์อัจฉริยะที่เหมาะสมขึ้นอยู่กับความต้องการของคุณ

Box<T>: ใช้เมื่อต้องการนำข้อมูลไปไว้บนฮีป โดยทั่วไปใช้กับความเป็นเจ้าของรายเดียวหรือชนิดข้อมูลแบบเรียกซ้ำ
Rc<T>: ใช้เมื่อต้องการให้ข้อมูลมีเจ้าของหลายรายในบริบทที่มี เธรดเดียว
Arc<T>: ใช้เมื่อต้องการให้ข้อมูลมีเจ้าของหลายรายในบริบทที่มี หลายเธรด หรือทำงานพร้อมกัน

หากไม่จำเป็นต้องมีความปลอดภัยสำหรับเธรด ให้เลือกใช้ Box หรือ Rc ก่อนเสมอ เพราะ Arc มีต้นทุนด้านประสิทธิภาพ

ตรวจสอบความเข้าใจเรื่องพอยน์เตอร์อัจฉริยะ

คุณต้องจัดเก็บไฟล์รูปภาพขนาดใหญ่ไว้บนฮีป และมีเพียงส่วนเดียวของโปรแกรมที่เป็นเจ้าของและจัดการไฟล์นั้น คุณควรใช้พอยน์เตอร์อัจฉริยะใด

ทบทวน: พอยน์เตอร์อัจฉริยะ

ในบทเรียนนี้ คุณได้เรียนรู้เกี่ยวกับพอยน์เตอร์อัจฉริยะพื้นฐานสามชนิดของ Rust

Box<T>: ใช้จัดสรรข้อมูลบนฮีปเมื่อมีเจ้าของเพียงรายเดียว
Rc<T>: ใช้ทำให้ข้อมูลมีเจ้าของหลายรายในสภาพแวดล้อมที่มีเธรดเดียว
Arc<T>: ใช้ทำให้ข้อมูลมีเจ้าของหลายรายที่ปลอดภัยสำหรับเธรดในสภาพแวดล้อมที่มีหลายเธรด

พอยน์เตอร์อัจฉริยะเหล่านี้ช่วยให้คุณควบคุมการจัดการหน่วยความจำได้มากขึ้น พร้อมใช้ประโยชน์จากการรับรองความปลอดภัยของ Rust

คำถามที่พบบ่อย

บทเรียน “ตัวชี้อัจฉริยะ Box, Rc และ Arc” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “ตัวชี้อัจฉริยะ Box, Rc และ Arc” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Learn Rust Coding ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Learn Rust Coding มีบทเรียนทั้งหมด 3 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “ตัวชี้อัจฉริยะ Box, Rc และ Arc”

ทำความเข้าใจวิธีที่ `Box` สำหรับการจัดสรรบนฮีป `Rc` สำหรับความเป็นเจ้าของร่วม และ `Arc` สำหรับความเป็นเจ้าของร่วมที่ปลอดภัยต่อเธรด ใช้จัดการข้อมูล คุณปฏิบัติ Learn Rust Coding ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Learn Rust Coding หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Learn Rust Coding บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 3 บทเรียน

บทเรียน “ตัวชี้อัจฉริยะ Box, Rc และ Arc” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Learn Rust Coding นี้ได้ไหม

ได้ บทเรียน Learn Rust Coding ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ Learn Rust Coding