ทำไมต้องมีการรวบรวมขยะหากตัวชี้สมาร์ทอยู่ที่นั่น

วันนี้มีหลายภาษาที่เก็บขยะ มันยังสามารถใช้ได้สำหรับ C ++ โดยบุคคลที่สาม แต่ C ++ มี RAII และตัวชี้อัจฉริยะ ดังนั้นจุดประสงค์ของการใช้การรวบรวมขยะคืออะไร? มันทำอะไรพิเศษหรือไม่?

และในภาษาอื่นเช่น C # หากการอ้างอิงทั้งหมดถูกใช้เป็นพอยน์เตอร์อัจฉริยะ (เก็บ RAII ไว้) ตามสเปคและการใช้งานจะยังคงมีความต้องการของนักสะสมขยะหรือไม่? ถ้าไม่เป็นเช่นนั้นทำไมจึงไม่เป็นเช่นนั้น

ดังนั้นจุดประสงค์ในการใช้การรวบรวมขยะคืออะไร

ฉันสมมติว่าคุณหมายถึงการอ้างอิงสมาร์ทพอยน์เตอร์นับและฉันจะทราบว่าพวกเขาเป็นรูปแบบของการเก็บขยะ (พื้นฐาน) ดังนั้นฉันจะตอบคำถาม "อะไรคือข้อดีของการเก็บขยะในรูปแบบอื่น ๆ แทน.

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

• ทางเข้า สมาร์ทพอยน์เตอร์เป็นหนึ่งในรูปแบบการรวบรวมขยะที่มีประสิทธิภาพน้อยที่สุดโดยเฉพาะอย่างยิ่งในบริบทของแอพพลิเคชั่นแบบมัลติเธรดเมื่อจำนวนการอ้างอิงถูกชนด้วยอะตอม มีเทคนิคการนับการอ้างอิงขั้นสูงที่ออกแบบมาเพื่อบรรเทาปัญหานี้ แต่การติดตาม GCs ยังคงเป็นอัลกอริทึมของตัวเลือกในสภาพแวดล้อมการผลิต

• ความแอบแฝง การใช้งานตัวชี้สมาร์ททั่วไปจะช่วยให้ destructors หิมะถล่มส่งผลให้เวลาหยุดชั่วคราวมากมาย การเก็บขยะในรูปแบบอื่น ๆ นั้นมีจำนวนเพิ่มมากขึ้นและอาจเป็นเวลาจริงเช่นลู่วิ่งของ Baker

เนื่องจากไม่มีใครมองจากมุมนี้ฉันจะใช้ถ้อยคำใหม่คำถามของคุณ: ทำไมใส่อะไรลงไปในภาษาถ้าคุณทำได้ในห้องสมุด? การละเว้นการใช้งานเฉพาะและรายละเอียดเกี่ยวกับวากยสัมพันธ์ตัวชี้ GC / สมาร์ทนั้นเป็นกรณีพิเศษของคำถาม เหตุใดจึงต้องกำหนดตัวรวบรวมขยะในภาษาของตัวเองถ้าคุณสามารถนำไปใช้ในห้องสมุดได้?

มีสองคำตอบสำหรับคำถามนั้น สำคัญที่สุดก่อน:

1. คุณมั่นใจได้ว่ารหัสทั้งหมดสามารถใช้เพื่อทำงานร่วมกันได้ นี่คือผมคิดว่าเหตุผลใหญ่ว่าทำไมนำมาใช้รหัสและการแบ่งปันรหัสไม่ได้จริงๆจะปิดจนกว่า Java / C # / หลาม / ทับทิม ห้องสมุดจำเป็นต้องสื่อสารและภาษาที่ใช้ร่วมกันที่เชื่อถือได้เพียงอย่างเดียวคือสิ่งที่อยู่ในข้อมูลจำเพาะภาษา (และในระดับมาตรฐานของห้องสมุด) หากคุณเคยพยายามนำไลบรารี่กลับมาใช้ใหม่ใน C ++ คุณอาจประสบกับความเจ็บปวดอันน่าสยดสยองที่ไม่มีความหมายแบบมาตรฐานของหน่วยความจำเกิดขึ้น ฉันต้องการส่งผ่านโครงสร้างไปยัง lib บางส่วน ฉันจะผ่านการอ้างอิงได้หรือไม่ ชี้? ?scoped_ptrsmart_ptr? ฉันกำลังผ่านการเป็นเจ้าของหรือไม่? มีวิธีที่จะระบุว่า? เกิดอะไรขึ้นถ้า lib ต้องการจัดสรร? ฉันต้องจัดสรรให้หรือไม่ การไม่ทำให้ส่วนของการจัดการหน่วยความจำของภาษา C ++ บังคับให้แต่ละคู่ไลบรารีต้องเจรจากลยุทธ์เฉพาะของตนเองที่นี่และเป็นการยากที่จะให้ทุกคนเห็นด้วย GC ทำให้ไม่ใช่ประเด็นที่สมบูรณ์

2. คุณสามารถออกแบบไวยากรณ์ที่อยู่รอบ ๆ เนื่องจาก C ++ ไม่ได้ห่อหุ้มการจัดการหน่วยความจำของตัวเองจึงต้องมีช่วงของฮุก syntactic เพื่อให้รหัสระดับผู้ใช้แสดงรายละเอียดทั้งหมด คุณมีพอยน์เตอร์, การอ้างอิง, constโอเปอเรเตอร์ dereferencing, โอเปอเรเตอร์ทางอ้อม, ที่อยู่ของ ฯลฯ หากคุณม้วนการจัดการหน่วยความจำเป็นภาษาของตัวเองไวยากรณ์สามารถออกแบบได้ ตัวดำเนินการทั้งหมดนั้นหายไปและภาษาก็ดูสะอาดและเรียบง่ายขึ้น

3. คุณได้รับผลตอบแทนสูงจากการลงทุน ค่าใด ๆ ของรหัสที่สร้างจะถูกคูณด้วยจำนวนผู้ใช้ ซึ่งหมายความว่ายิ่งมีผู้ใช้มากเท่าไหร่คุณก็จะสามารถใช้จ่ายกับซอฟต์แวร์ได้มากขึ้นเท่านั้น เมื่อคุณย้ายคุณลักษณะที่เป็นภาษาที่ทุกผู้ใช้ภาษาที่จะใช้มัน ซึ่งหมายความว่าคุณสามารถจัดสรรความพยายามได้มากกว่าที่จะทำได้กับไลบรารีที่ใช้โดยชุดย่อยของผู้ใช้เหล่านั้นเท่านั้น นี่คือเหตุผลที่ภาษาอย่าง Java และ C # มี VM อันดับหนึ่งอย่างแน่นอนและนักสะสมขยะคุณภาพสูงอย่างน่าอัศจรรย์ค่าใช้จ่ายในการพัฒนาจะถูกตัดจำหน่ายไปยังผู้ใช้หลายล้านคน

การรวบรวมขยะนั้นหมายถึงว่าวัตถุที่คุณจัดสรรจะถูกปล่อยออกมาโดยอัตโนมัติเมื่อถึงจุดที่ไม่สามารถเข้าถึงได้อีกต่อไป

ถูกต้องมากขึ้นพวกเขาจะถูกปล่อยออกมาเมื่อพวกเขาไม่สามารถเข้าถึงโปรแกรมได้เนื่องจากวัตถุที่อ้างอิงเป็นวงกลมจะไม่ถูกปล่อยออกมาอย่างอื่น

พอยน์เตอร์สมาร์ทเพียงอ้างถึงโครงสร้างใด ๆ ที่ทำงานเหมือนตัวชี้ธรรมดา แต่มีฟังก์ชั่นพิเศษบางอย่างแนบมา สิ่งเหล่านี้รวมถึงแต่ไม่ จำกัด เพียงการจัดสรรคืน แต่ยังรวมถึงการคัดลอกเมื่อเขียนเช็คที่ถูกผูกไว้ ...

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

แต่ขบวนความคิดดำเนินไปในทางต่อไปนี้:

1. การเก็บขยะเป็นสิ่งที่ยอดเยี่ยมเพราะสะดวกและฉันต้องดูแลสิ่งต่าง ๆ ให้น้อยลง
2. ดังนั้น: ฉันต้องการเก็บขยะในภาษาของฉัน
3. ตอนนี้จะนำ GC มาเป็นภาษาของฉันได้อย่างไร

แน่นอนคุณสามารถออกแบบมันได้ตั้งแต่ต้น C # ได้รับการออกแบบมาให้รวบรวมขยะดังนั้นเพียงแค่newวัตถุของคุณและมันจะถูกปล่อยออกมาเมื่อการอ้างอิงไม่อยู่ในขอบเขต วิธีการทำสิ่งนี้ขึ้นอยู่กับคอมไพเลอร์

แต่ใน C ++ ไม่มีการรวบรวมขยะ หากเราจัดสรรตัวชี้บางส่วนint* p = new int;และอยู่นอกขอบเขตpตัวเองจะถูกลบออกจากสแต็ก แต่ไม่มีใครดูแลหน่วยความจำที่จัดสรร

ตอนนี้สิ่งเดียวที่คุณต้องเริ่มต้นจากการเป็นdestructors กำหนด เมื่อวัตถุออกจากขอบเขตมันถูกสร้างขึ้นในตัวทำลายมันจะถูกเรียก เมื่อรวมกับเทมเพลตและการบรรทุกเกินพิกัดคุณสามารถออกแบบวัตถุห่อหุ้มที่ทำตัวเหมือนตัวชี้ แต่ใช้ฟังก์ชั่น destructor เพื่อล้างทรัพยากรที่แนบมากับมัน (RAII) คุณเรียกนี้ชี้สมาร์ท

นี่คือเฉพาะ C ++ สูงทั้งหมด: การบรรทุกเกินพิกัด, เทมเพลต, destructors, ... ในสถานการณ์เฉพาะภาษานี้คุณได้พัฒนาพอยน์เตอร์อัจฉริยะเพื่อให้ GC ที่คุณต้องการ

แต่ถ้าคุณออกแบบภาษาด้วย GC ตั้งแต่เริ่มต้นนี่เป็นเพียงรายละเอียดการนำไปใช้งาน คุณแค่บอกว่าวัตถุจะถูกล้างและคอมไพเลอร์จะทำสิ่งนี้ให้คุณ

พอยน์เตอร์สมาร์ทเช่นใน C ++ อาจจะไม่สามารถทำได้ในภาษาอย่าง C # ซึ่งไม่มีการทำลายที่กำหนดเลย (C # ทำงานได้โดยการให้น้ำตาล syntactic สำหรับการเรียก.Dispose()วัตถุบางอย่าง) ในที่สุดทรัพยากรที่ไม่มีการอ้างอิงจะถูกเรียกคืนโดย GC แต่จะไม่ได้กำหนดเมื่อจะเกิดขึ้นอย่างแน่นอน

และในทางกลับกันก็ทำให้ GC สามารถทำงานได้อย่างมีประสิทธิภาพ ถูกฝังลึกในภาษามากกว่าตัวชี้สมาร์ทซึ่งตั้งอยู่ด้านบนของมัน. NET GC สามารถเช่นการดำเนินการหน่วยความจำล่าช้าและดำเนินการในหน่วยบล็อกเพื่อให้ถูกกว่าหรือย้ายหน่วยความจำรอบเพื่อเพิ่มประสิทธิภาพตามวัตถุบ่อย มีการเข้าถึง

ในใจของฉันมีความแตกต่างใหญ่สองอย่างระหว่างการรวบรวมขยะและตัวชี้อัจฉริยะที่ใช้สำหรับการจัดการหน่วยความจำ:

1. ตัวชี้สมาร์ทไม่สามารถรวบรวมขยะแบบวนได้ การเก็บขยะสามารถ
2. พอยน์เตอร์อัจฉริยะทำงานทุกอย่างในช่วงเวลาของการอ้างอิงการอ้างอิงและการจัดสรรคืนบนเธรดแอปพลิเคชัน การเก็บขยะไม่จำเป็น

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

หลังหมายความว่าไม่ว่าสมาร์ทพอยน์เตอร์จะฉลาดแค่ไหนการทำงานของมันจะทำให้เธรดการทำงานช้าลงในโปรแกรมของคุณ การรวบรวมขยะสามารถเลื่อนการทำงานและย้ายไปยังเธรดอื่น ที่ช่วยให้มีประสิทธิภาพโดยรวมมากขึ้น (จริง ๆ แล้วต้นทุนรันไทม์ของ GC สมัยใหม่น้อยกว่าระบบ malloc / free ปกติแม้ไม่มีค่าใช้จ่ายเพิ่มเติมของตัวชี้สมาร์ท) และทำสิ่งที่มันยังคงต้องทำโดยไม่ต้องเข้า ทางของแอปพลิเคชันเธรด

ตอนนี้โปรดทราบว่าตัวชี้อัจฉริยะซึ่งเป็นโครงสร้างเชิงโปรแกรมสามารถใช้ทำสิ่งที่น่าสนใจอื่น ๆ ได้ทุกประเภท - ดูคำตอบของ Dario - ซึ่งอยู่นอกขอบเขตของการรวบรวมขยะ หากคุณต้องการทำสิ่งเหล่านี้คุณจะต้องมีพอยน์เตอร์อัจฉริยะ

อย่างไรก็ตามเพื่อจุดประสงค์ในการจัดการหน่วยความจำฉันไม่เห็นโอกาสของตัวชี้สมาร์ทแทนที่การรวบรวมขยะ พวกเขาไม่เก่งเท่าที่ควร

คำว่าการรวบรวมขยะหมายถึงมีขยะใด ๆ ที่จะรวบรวม ในพอยน์เตอร์อัจฉริยะ C ++ มีหลากหลายรสชาติที่สำคัญที่สุดคือ unique_ptr unique_ptr นั้นโดยทั่วไปแล้วจะเป็นเจ้าของและสร้างแบบกำหนดขอบเขต ในโค้ดที่ได้รับการออกแบบมาเป็นอย่างดีโดยปกติแล้วกองสิ่งของที่จัดสรรส่วนใหญ่จะอาศัยอยู่หลังตัวชี้สมาร์ท unique_ptr และความเป็นเจ้าของทรัพยากรเหล่านั้นจะถูกกำหนดไว้อย่างดีตลอดเวลา แทบจะไม่มีค่าใช้จ่ายใด ๆ ใน unique_ptr และ unique_ptr ขจัดปัญหาการจัดการหน่วยความจำแบบแมนนวลส่วนใหญ่ซึ่งมักจะผลักดันผู้คนไปสู่ภาษาที่มีการจัดการ ตอนนี้แกนประมวลผลที่ทำงานพร้อมกันมากขึ้นกลายเป็นสินค้าทั่วไปหลักการออกแบบที่รหัสไดรฟ์เพื่อใช้ความเป็นเจ้าของที่ไม่เหมือนใครและชัดเจนในทุกเวลากลายเป็นสิ่งสำคัญสำหรับประสิทธิภาพ

แม้ในโปรแกรมที่ออกแบบมาเป็นอย่างดีโดยเฉพาะอย่างยิ่งในสภาพแวดล้อมแบบมัลติเธรดไม่สามารถแสดงทุกสิ่งได้หากไม่มีโครงสร้างข้อมูลที่ใช้ร่วมกันและสำหรับโครงสร้างข้อมูลที่ต้องการจริงๆเธรดจำเป็นต้องสื่อสาร RAII ใน c ++ ทำงานได้ค่อนข้างดีสำหรับความกังวลเกี่ยวกับอายุการใช้งานในการตั้งค่าเธรดเดียวในการตั้งค่าแบบมัลติเธรดอายุการใช้งานของวัตถุอาจไม่สมบูรณ์ตามลำดับชั้นสแต็ก สำหรับสถานการณ์เหล่านี้การใช้ shared_ptr เสนอส่วนใหญ่ของการแก้ปัญหา คุณสร้างความเป็นเจ้าของร่วมกันของทรัพยากรและสิ่งนี้ใน C ++ เป็นสถานที่เดียวที่เราเห็นขยะ แต่ในปริมาณน้อยเช่นนั้นโปรแกรม c ++ ที่เหมาะสมควรได้รับการพิจารณามากขึ้นในการนำคอลเลกชัน 'litter' มาใช้ร่วมกับ ptr ของ ดำเนินการในภาษาอื่น ๆ C ++ ไม่ได้มี 'ขยะ' มากนัก

ตามที่ระบุไว้โดยผู้อื่นตัวชี้สมาร์ทนับที่อ้างอิงเป็นหนึ่งในรูปแบบของการเก็บขยะและสำหรับที่มีปัญหาสำคัญหนึ่ง ตัวอย่างที่ใช้ส่วนใหญ่เป็นข้อเสียเปรียบของรูปแบบการนับจำนวนการอ้างอิงขยะคือปัญหาของการสร้างโครงสร้างข้อมูลที่ถูกโยงถึงที่เชื่อมต่อกับตัวชี้สมาร์ทซึ่งกันและกันซึ่งสร้างกลุ่มวัตถุที่กันไม่ให้ถูกรวบรวม ในขณะที่โปรแกรมที่ออกแบบตามแบบจำลองการคำนวณของนักแสดงโครงสร้างข้อมูลมักไม่อนุญาตให้เกิดกลุ่มที่ไม่สามารถรวบรวมได้ใน C ++ เมื่อคุณใช้วิธีการแชร์ข้อมูลแบบกว้างในการเขียนโปรแกรมแบบมัลติเธรดตามที่ใช้เป็นส่วนใหญ่ ของอุตสาหกรรมกลุ่มเด็กกำพร้าเหล่านี้สามารถกลายเป็นความจริงได้อย่างรวดเร็ว

ดังนั้นการสรุปทั้งหมดถ้าใช้ตัวชี้ที่ใช้ร่วมกันคุณหมายถึงการใช้งานที่กว้างขวางของ unique_ptr รวมกับรูปแบบนักแสดงของวิธีการคำนวณสำหรับการเขียนโปรแกรมแบบมัลติเธรดและการใช้งานแบบ จำกัด ของ shared_ptr กว่าการเก็บขยะในรูปแบบอื่น ๆ สิทธิประโยชน์เพิ่มเติม ถ้าคุณใช้วิธีแชร์ทุกอย่างจะทำให้คุณจบลงด้วย shared_ptr ทั่วทุกสถานที่กว่าที่คุณควรพิจารณาเปลี่ยนรูปแบบการทำงานพร้อมกันหรือเปลี่ยนไปใช้ภาษาที่มีการจัดการซึ่งมุ่งเน้นไปที่การแบ่งปันความเป็นเจ้าของที่กว้างขึ้น

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

ปัญหาคือถ้าคุณมีการอ้างอิงแบบวงกลม นั่นคือ A มีการอ้างอิงถึง B, B มีการอ้างอิงถึง C และ C มีการอ้างอิงถึง A หากคุณใช้ตัวชี้สมาร์ทดังนั้นเพื่อที่จะเพิ่มหน่วยความจำที่เกี่ยวข้องกับ A, B & C คุณต้องด้วยตนเอง เข้าไปที่นั่น "ทำลาย" การอ้างอิงแบบวงกลม (เช่นใช้weak_ptrใน C ++)

การรวบรวมขยะ (โดยทั่วไป) ทำงานแตกต่างกันมาก ส่วนใหญ่นักสะสมขยะวันนี้ใช้ทดสอบการเชื่อม นั่นคือมันดูที่อ้างอิงในกองและคนที่จะสามารถเข้าถึงได้ทั่วโลกแล้วมีร่องรอยของวัตถุที่อ้างอิงเหล่านั้นหมายถึงทุกคนและวัตถุที่พวกเขาอ้างถึง ฯลฯ ทุกสิ่งทุกอย่างเป็นขยะ

ด้วยวิธีนี้การอ้างอิงแบบวนรอบไม่สำคัญอีกต่อไป - ตราบใดที่ไม่สามารถเข้าถึง A, B และ C ได้หน่วยความจำสามารถเรียกคืนได้

มีข้อดีอื่น ๆ ในการเก็บขยะ "ของจริง" ตัวอย่างเช่นการจัดสรรหน่วยความจำมีราคาถูกมาก: เพียงเพิ่มตัวชี้ไปที่ "สิ้นสุด" ของบล็อกหน่วยความจำ การจัดสรรคืนมีค่าใช้จ่ายตัดจำหน่ายอย่างต่อเนื่องเช่นกัน แต่แน่นอนว่าภาษาอย่าง C ++ ช่วยให้คุณสามารถนำการจัดการหน่วยความจำไปใช้ในแบบที่คุณชอบได้ดังนั้นคุณจึงสามารถวางแผนกลยุทธ์การจัดสรรที่รวดเร็วยิ่งขึ้น

แน่นอนว่าใน C ++ จำนวนหน่วยความจำที่จัดสรรฮีปมักจะน้อยกว่าภาษาอ้างอิงหนักเช่น C # /. NET แต่นั่นไม่ใช่ปัญหาการรวบรวมขยะกับตัวชี้สมาร์ท

ในกรณีใด ๆ ปัญหาไม่ได้ถูกตัดและแบบแห้งดีกว่าแบบอื่น พวกเขาแต่ละคนมีข้อดีและข้อเสีย

มันเป็นเรื่องของประสิทธิภาพการทำงาน หน่วยความจำที่ไม่สามารถจัดสรรได้นั้นต้องการการดูแลระบบจำนวนมาก หากการยกเลิกการจัดสรรทำงานในพื้นหลังประสิทธิภาพของกระบวนการพื้นหน้าจะเพิ่มขึ้น โชคไม่ดีที่การจัดสรรหน่วยความจำไม่สามารถขี้เกียจ (วัตถุที่จัดสรรจะถูกนำมาใช้ในช่วงเวลาศักดิ์สิทธิ์ถัดไป) แต่การปล่อยวัตถุสามารถทำได้

ลองใช้ C ++ (โดยไม่มี GC ใด ๆ ) เพื่อจัดสรรวัตถุจำนวนมากพิมพ์ "hello" แล้วลบออก คุณจะประหลาดใจว่าต้องใช้เวลานานแค่ไหนในการปลดปล่อยวัตถุ

นอกจากนี้ GNU libc มีเครื่องมือที่มีประสิทธิภาพมากขึ้นสำหรับหน่วยความจำ unallocating ดูobstacks ต้องสังเกตุว่าฉันไม่มีประสบการณ์กับสิ่งกีดขวางฉันไม่เคยใช้มัน

การรวบรวมขยะอาจมีประสิทธิภาพมากขึ้น - โดยทั่วไปแล้ว 'เป็นชุด' ค่าโสหุ้ยของการจัดการหน่วยความจำและทำได้ทั้งหมดในครั้งเดียว โดยทั่วไปสิ่งนี้จะส่งผลให้ CPU โดยรวมน้อยลงเมื่อใช้การจัดสรรหน่วยความจำ แต่หมายความว่าคุณจะมีกิจกรรมการจัดสรรจัดสรรจำนวนมากในบางจุด หาก GC ไม่ได้รับการออกแบบอย่างเหมาะสมผู้ใช้สามารถมองเห็นได้เป็น 'หยุดชั่วคราว' ในขณะที่ GC พยายามจัดสรรหน่วยความจำ GCs ที่ทันสมัยส่วนใหญ่เก่งในการรักษาสิ่งนี้ให้ผู้ใช้มองไม่เห็นยกเว้นภายใต้เงื่อนไขที่ไม่พึงประสงค์มากที่สุด

ตัวชี้อัจฉริยะ (หรือรูปแบบการนับการอ้างอิงใด ๆ ) มีข้อได้เปรียบที่เกิดขึ้นอย่างแน่นอนเมื่อคุณคาดหวังจากการดูรหัส (ตัวชี้สมาร์ทไม่อยู่ในขอบเขตสิ่งที่ถูกลบ) คุณจะได้รับการจัดสรรจำนวนเล็กน้อยที่นี่และที่นั่น โดยรวมคุณอาจใช้เวลา CPU มากขึ้นในการยกเลิกการจัดสรร แต่เนื่องจากมันแพร่กระจายไปทั่วทุกสิ่งที่เกิดขึ้นในโปรแกรมของคุณจึงมีโอกาสน้อยลง (การยกเลิกการจัดสรรโครงสร้างข้อมูลมอนสเตอร์บางส่วน) เพื่อให้ผู้ใช้ของคุณมองเห็นได้

หากคุณกำลังทำสิ่งที่การตอบสนองมีความสำคัญฉันขอแนะนำให้ตัวชี้อัจฉริยะ / การนับการอ้างอิงแจ้งให้คุณทราบอย่างชัดเจนว่าเกิดเหตุการณ์ใดขึ้นบ้างเพื่อให้คุณสามารถทราบได้ในขณะที่เข้ารหัสสิ่งที่ผู้ใช้มองเห็น ในการตั้งค่า GC คุณมีเพียงตัวควบคุมที่ไม่สามารถควบคุมตัวเก็บขยะได้มากที่สุดและต้องพยายามแก้ไขสิ่งต่างๆ

ในทางกลับกันถ้าปริมาณงานโดยรวมเป็นเป้าหมายของคุณระบบที่ใช้ GC อาจเป็นทางเลือกที่ดีกว่าเนื่องจากช่วยลดทรัพยากรที่จำเป็นในการจัดการหน่วยความจำให้เหลือน้อยที่สุด

รอบ: ฉันไม่คิดว่าปัญหาของรอบจะเป็นสิ่งสำคัญ ในระบบที่คุณมีพอยน์เตอร์อัจฉริยะคุณมีแนวโน้มไปสู่โครงสร้างข้อมูลที่ไม่มีวัฏจักรหรือคุณเพียงระมัดระวังเกี่ยวกับวิธีปล่อยสิ่งต่าง ๆ หากจำเป็นผู้รักษาวัตถุที่รู้วิธีการทำลายวงจรในวัตถุที่เป็นเจ้าของสามารถใช้เพื่อประกันการทำลายที่เหมาะสมโดยอัตโนมัติ ในบางส่วนของการเขียนโปรแกรมสิ่งนี้อาจมีความสำคัญ แต่สำหรับงานประจำวันส่วนใหญ่มันไม่เกี่ยวข้อง

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

สิ่งนี้เกิดขึ้นเนื่องจากตัวชี้สมาร์ทต้องทำการกระทำเฉพาะซึ่งจะไม่ถูก triigered ในสถานการณ์ข้างต้นเนื่องจากวัตถุทั้งสองไม่สามารถเข้าถึงโปรแกรมได้ การรวบรวมขยะจะรับมือได้ - มันจะระบุได้อย่างถูกต้องว่าวัตถุนั้นไม่สามารถเข้าถึงได้ในโปรแกรมและจะถูกรวบรวม

มันเป็นคลื่นความถี่

หากคุณไม่ได้ จำกัด ขอบเขตในการแสดงและพร้อมที่จะใส่เครื่องบดคุณจะต้องลงเอยด้วยการชุมนุมหรือคกับความรับผิดชอบทั้งหมดที่คุณมีเพื่อการตัดสินใจที่ถูกต้องและอิสระในการทำเช่นนั้น อิสระที่จะทำให้ยุ่งเหยิง:

"ฉันจะบอกคุณว่าต้องทำอย่างไรคุณทำได้เชื่อฉัน"

การรวบรวมขยะคือส่วนอื่น ๆ ของสเปกตรัม คุณมีการควบคุมน้อยมาก แต่ก็มีการดูแลสำหรับคุณ:

"ฉันจะบอกคุณว่าฉันต้องการคุณทำให้มันเกิดขึ้น"

สิ่งนี้มีข้อดีมากมายซึ่งส่วนใหญ่คุณไม่จำเป็นต้องเชื่อถือได้เมื่อรู้ว่าเมื่อไรไม่จำเป็นต้องใช้ทรัพยากรอีกต่อไป แต่ (แม้จะมีคำตอบบางส่วนที่ลอยอยู่รอบ ๆ ที่นี่) ก็ไม่ดีต่อประสิทธิภาพและ การคาดการณ์ประสิทธิภาพ (เช่นเดียวกับทุกสิ่งหากคุณได้รับการควบคุมและทำสิ่งที่โง่คุณสามารถมีผลลัพธ์ที่แย่กว่านั้นได้อย่างไรก็ตามเพื่อแนะนำให้รู้ว่าเมื่อรวบรวมเวลาสิ่งที่เงื่อนไขสำหรับความสามารถในการเพิ่มหน่วยความจำนั้นไม่สามารถใช้งานได้ ไร้เดียงสา)

RAII, การกำหนดขอบเขต, การนับการอ้างอิงและอื่น ๆล้วนเป็นผู้ช่วยที่ช่วยให้คุณเคลื่อนไหวต่อไปตามคลื่นความถี่นั้น ทุกสิ่งเหล่านี้ยังคงต้องการการใช้งาน พวกเขายังคงให้และต้องการให้คุณโต้ตอบกับการจัดการหน่วยความจำในลักษณะที่การเก็บขยะไม่ได้

โปรดจำไว้ว่าในท้ายที่สุดทุกอย่างก็จะไหลลงสู่คำสั่งในการใช้งานซีพียู ตามความรู้ของฉันซีพียูระดับผู้บริโภคทั้งหมดมีชุดคำสั่งที่คุณต้องมีข้อมูลที่เก็บไว้ในสถานที่ที่กำหนดในหน่วยความจำและคุณมีตัวชี้ไปยังข้อมูลดังกล่าว นั่นคือทั้งหมดที่คุณมีในระดับพื้นฐาน

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