เพิ่มเติมเกี่ยวกับคนเก็บขยะ

สวัสดี! ในบทเรียนที่แล้ว เราได้ทำความคุ้นเคยกับตัวรวบรวมขยะในตัวของ Java เป็นครั้งแรก และได้ทราบคร่าวๆ ว่ามันทำงานอย่างไร มันทำงานในพื้นหลังในขณะที่โปรแกรมของคุณกำลังทำงาน รวบรวมวัตถุที่ไม่จำเป็นซึ่งจะถูกลบในภายหลัง ดังนั้นจึงเพิ่มหน่วยความจำที่สามารถใช้สร้างวัตถุใหม่ในอนาคต ในบทเรียนนี้ เราจะพูดถึงวิธีการทำงานอย่างละเอียดมากขึ้น ตัวอย่างเช่น วัตถุจะกลายเป็นสิ่งที่ไม่จำเป็นได้อย่างไรและเมื่อใด แล้วคนเก็บขยะจะรู้ได้อย่างไร? นี่คือคำถามที่เราจะตอบในบทเรียนของวันนี้ :) บทเรียนจะเป็นเหมือนภาพรวมมากกว่า: คุณไม่จำเป็นต้องเรียนรู้เนื้อหานี้ด้วยใจจริง จุดประสงค์หลักคือเพื่อขยายขอบเขตการมองเห็นของคุณเกี่ยวกับวิธีการทำงานของหน่วยความจำและตัวเก็บขยะ ดังนั้นอ่านให้จบและค้นหาสิ่งใหม่สำหรับตัวคุณเอง :) ไปกันเลย! สิ่งแรกที่คุณต้องจำไว้คือตัวรวบรวมขยะทำงานควบคู่ไปกับโปรแกรมของคุณ. ไม่ใช่ส่วนหนึ่งของโปรแกรมของคุณ มันทำงานแยกกัน (ในบทเรียนที่แล้ว เราเปรียบเทียบสิ่งนี้กับหุ่นยนต์ดูดฝุ่น) แต่ก็ไม่ได้เป็นเช่นนั้นเสมอไป การรวบรวมขยะเคยดำเนินการในเธรดเดียวกันกับโปรแกรมของคุณ ในบางกำหนดการ (ทุกๆ สองสามนาที) ตัวเก็บขยะจะตรวจหาวัตถุที่ไม่ต้องการในโปรแกรม ปัญหาคือโปรแกรมจะหยุดทำงาน (ไม่ทำงาน) ระหว่างการตรวจสอบและการรวบรวมขยะนี้ ลองนึกภาพว่าคุณกำลังนั่งอยู่ในที่ทำงาน แต่แล้วพนักงานทำความสะอาดก็เข้ามาล้างพื้น เธอไล่คุณออกจากคอมพิวเตอร์เป็นเวลา 5 นาที และคุณรอจนกว่าเธอจะทำความสะอาดเสร็จ ในช่วงเวลานี้ คุณไม่สามารถทำงานได้ นั่นคือวิธีการทำงานของการรวบรวมขยะ :) กลไกนี้มีการเปลี่ยนแปลงในภายหลัง และตอนนี้ตัวรวบรวมขยะทำงานในพื้นหลัง ไม่เป็นอุปสรรคต่อการทำงานของตัวโปรแกรมเอง คุณรู้อยู่แล้วว่าวัตถุตายเมื่อไม่มีการอ้างอิงอีกต่อไป ในความเป็นจริง,ตัวรวบรวมขยะไม่นับการอ้างอิงวัตถุ ขั้นแรก อาจใช้เวลานาน ประการที่สอง มันไม่ได้มีประสิทธิภาพมาก ท้ายที่สุดแล้ว วัตถุต่างๆ สามารถอ้างอิงถึงกันได้! รูปภาพแสดงตัวอย่างที่วัตถุ 3 ชิ้นอ้างอิงถึงกัน แต่ไม่มีใครอ้างถึงวัตถุเหล่านั้น กล่าวอีกนัยหนึ่งโปรแกรมที่เหลือไม่ต้องการ หากตัวรวบรวมขยะเพียงนับการอ้างอิง วัตถุ 3 ชิ้นนี้จะไม่ถูกรวบรวมและหน่วยความจำจะไม่ถูกปลดปล่อย (มีการอ้างอิงถึงพวกมัน!) เราสามารถเปรียบเทียบสิ่งนี้ได้กับยานอวกาศ ในระหว่างการบิน นักบินอวกาศตัดสินใจที่จะตรวจสอบรายการอะไหล่ที่สามารถซ่อมแซมได้ เหนือสิ่งอื่นใดพวกเขาพบพวงมาลัยและแป้นเหยียบจากรถธรรมดา เห็นได้ชัดว่าไม่จำเป็นที่นี่และใช้พื้นที่โดยไม่จำเป็น (แม้ว่าสองส่วนนี้จะเกี่ยวข้องกันและมีฟังก์ชันบางอย่าง) แต่ภายในยานอวกาศ พวกมันคือขยะไร้ประโยชน์ที่ควรทิ้ง ดังนั้นใน Java จึงตัดสินใจรวบรวมขยะโดยไม่ได้อ้างอิงการนับเข้าถึงได้และไม่สามารถเข้าถึงได้ เราจะทราบได้อย่างไรว่าวัตถุสามารถเข้าถึงได้หรือไม่ ทั้งหมดนี้เป็นเพียงความเฉลียวฉลาด วัตถุสามารถเข้าถึงได้หากมีการอ้างอิงโดยวัตถุอื่นที่สามารถเข้าถึงได้ ดังนั้นเราจึงได้รับ "ห่วงโซ่แห่งการเข้าถึง" เริ่มต้นเมื่อโปรแกรมเริ่มต้นและดำเนินต่อไปตลอดระยะเวลาของโปรแกรม มีลักษณะดังนี้: ลูกศรในรูประบุรหัสปฏิบัติการของโปรแกรมของเรา รหัส (เช่นmain()วิธีการ) สร้างการอ้างอิงไปยังวัตถุ วัตถุเหล่านี้สามารถอ้างถึงวัตถุอื่นๆ วัตถุเหล่านั้นไปยังวัตถุอื่นๆ และอื่นๆ สิ่งนี้สร้างห่วงโซ่อ้างอิง. หากคุณสามารถติดตามเพื่อเชื่อมโยงจากอ็อบเจ็กต์ไปยัง "การอ้างอิงรูท" (อันที่สร้างขึ้นโดยตรงในโค้ดปฏิบัติการ) ก็จะถือว่าสามารถเข้าถึงได้ วัตถุดังกล่าวถูกทำเครื่องหมายเป็นสีดำในภาพ แต่วัตถุจะไม่สามารถเข้าถึงได้หากวัตถุหลุดออกจากห่วงโซ่นี้ กล่าวคือไม่มีตัวแปรใดในโค้ดที่กำลังดำเนินการอยู่ในขณะนี้ และไม่สามารถเข้าถึงได้ผ่าน "ห่วงโซ่อ้างอิง" ในโปรแกรมของเรา วัตถุสองชิ้นดังกล่าวจะถูกทำเครื่องหมายเป็นสีแดง โปรดทราบว่าวัตถุ "สีแดง" เหล่านี้มีการอ้างอิงซึ่งกันและกัน แต่อย่างที่เราพูดไปก่อนหน้านี้ ตัวรวบรวมขยะสมัยใหม่ของ Java ไม่นับการอ้างอิง กำหนดว่าวัตถุสามารถเข้าถึงได้หรือไม่สามารถเข้าถึงได้. ส่งผลให้วัตถุสีแดง 2 ชิ้นในภาพเข้ายึด ทีนี้มาดูกระบวนการทั้งหมดตั้งแต่ต้นจนจบ ในการทำเช่นนั้น เราจะดูวิธีการจัดเรียงหน่วยความจำใน Java ด้วย :) ออบเจกต์ Java ทั้งหมดจะถูกจัดเก็บไว้ในพื้นที่พิเศษของหน่วยความจำที่เรียกว่าฮีป ในภาษาประจำวัน กองมักหมายถึงกองสิ่งของที่กองรวมกันอยู่ แต่นั่นไม่ใช่สิ่งที่กองอยู่ใน Java โครงสร้างของมันมีเหตุผลและสมเหตุสมผลมาก เมื่อถึงจุดหนึ่ง โปรแกรมเมอร์ Java พบว่าออบเจกต์ทั้งหมดสามารถแบ่งออกได้เป็นสองประเภท: ออบเจกต์ธรรมดาและ"ออบเจกต์อายุยืน". "วัตถุที่มีอายุยืน" คือวัตถุที่รอดจากการเก็บขยะหลายรอบ พวกเขามักจะมีชีวิตอยู่จนกว่าโปรแกรมจะสิ้นสุดลง ในท้ายที่สุดกองเต็มซึ่งจัดเก็บวัตถุทั้งหมดถูกแบ่งออกเป็นหลายส่วน ส่วนแรกมีชื่อที่สวยงาม: eden(จากพระคัมภีร์ "สวนเอเดน") ชื่อนี้เหมาะสมแล้ว เพราะนี่คือที่ที่ออบเจกต์จบลงหลังจากสร้างออบเจกต์แล้ว นี่คือส่วนของหน่วยความจำที่สร้างวัตถุใหม่เมื่อเราใช้คำหลักใหม่ อาจมีการสร้างวัตถุจำนวนมาก เมื่อพื้นที่นี้หมด การรวบรวมขยะแบบ "รวดเร็ว" จะเริ่มขึ้น ต้องบอกว่าคนเก็บขยะฉลาดมาก เลือกอัลกอริทึมตามว่าฮีปมีขยะมากขึ้นหรือวัตถุมีชีวิตมากขึ้น หากวัตถุเกือบทั้งหมดเป็นขยะ ตัวรวบรวมจะทำเครื่องหมายวัตถุที่มีชีวิตและย้ายไปยังพื้นที่อื่นของหน่วยความจำ จากนั้นพื้นที่ปัจจุบันจะถูกล้างอย่างสมบูรณ์ ถ้าไม่มีขยะจำนวนมาก และฮีปส่วนใหญ่เป็นวัตถุที่มีชีวิต นักสะสมจะทำเครื่องหมายขยะ เคลียร์ขยะ และบรรจุวัตถุอื่นๆ เข้าด้วยกัน พวกเราพูด "พื้นที่เอาชีวิตรอด ในทางกลับกันพื้นที่เอาชีวิตรอด ก็แบ่งออกเป็น หลายชั่วอายุคน วัตถุแต่ละชิ้นเป็นของรุ่นใดรุ่นหนึ่งขึ้นอยู่กับจำนวนรอบของการเก็บขยะที่รอดชีวิต หากวัตถุรอดชีวิตจากการรวบรวมขยะหนึ่งรอบ แสดงว่าวัตถุนั้นอยู่ใน "รุ่นที่ 1" ถ้า 5 ก็ "รุ่นที่ 5" สวนเอเดนและพื้นที่เอาชีวิตรอดร่วมกันก่อตัวเป็นพื้นที่ที่เรียกว่าคนรุ่นใหม่ นอกจากคนรุ่นหนุ่มสาวแล้วกองยังมีพื้นที่แห่งความทรงจำอีกแห่งที่เรียกว่าคนรุ่นเก่า. นี่คือพื้นที่ที่วัตถุอายุยืนซึ่งรอดชีวิตจากการเก็บขยะมาหลายรอบ มีข้อดีในการทำให้พวกเขาแยกจากคนอื่นๆ ทั้งหมด การรวบรวมขยะทั้งหมดจะดำเนินการเฉพาะเมื่อรุ่นเก่าเต็ม กล่าวคือมีวัตถุที่มีอายุยืนยาวจำนวนมากในโปรแกรมที่มีหน่วยความจำไม่เพียงพอ กระบวนการนี้เกี่ยวข้องกับหน่วยความจำมากกว่าหนึ่งพื้นที่ โดยทั่วไปจะเกี่ยวข้องกับวัตถุทั้งหมดที่สร้างโดยเครื่อง Java โดยปกติจะใช้เวลาและทรัพยากรมากขึ้น นี่เป็นการตัดสินใจอย่างแม่นยำที่จะจัดเก็บวัตถุที่มีอายุการใช้งานยาวนานแยกจากกัน "การเก็บขยะด่วน" จะดำเนินการเมื่อพื้นที่อื่นหมด สิ่งนี้เกี่ยวข้องเพียงส่วนเดียว ซึ่งทำให้รวดเร็วและมีประสิทธิภาพมากขึ้น ในที่สุด เมื่อแม้แต่พื้นที่สำหรับวัตถุที่มีอายุยืนยังเต็ม การรวบรวมขยะทั้งหมดถูกเรียกใช้ ดังนั้นนักสะสมจึงใช้เครื่องมือที่ "หนักที่สุด" เฉพาะเมื่อไม่สามารถหลีกเลี่ยงได้ นี่คือการแสดงภาพของโครงสร้างฮีปและการรวบรวมขยะ: