ใน. NET เปอร์สเปคทีฟ:
คำตอบ:
คำอธิบายที่ดีที่สุดที่ฉันเคยเห็นอยู่ในบทที่ 7 ของรากฐานการเขียนโปรแกรม e-bookฟรี
โดยทั่วไปใน. NETหน่วยความจำรั่วจะเกิดขึ้นเมื่อออบเจ็กต์อ้างอิงถูกรูทและไม่สามารถรวบรวมขยะได้ สิ่งนี้เกิดขึ้นโดยไม่ตั้งใจเมื่อคุณยึดถือการอ้างอิงเกินขอบเขตที่ตั้งใจไว้
คุณจะรู้ว่าคุณมีรอยรั่วเมื่อเริ่มรับ OutOfMemoryExceptions หรือการใช้หน่วยความจำของคุณสูงกว่าที่คุณคาดไว้ ( PerfMonมีตัวนับหน่วยความจำที่ดี)
การทำความเข้าใจกับโมเดลหน่วยความจำของ. NETเป็นวิธีที่ดีที่สุดในการหลีกเลี่ยงมัน โดยเฉพาะการทำความเข้าใจเกี่ยวกับวิธีการทำงานของตัวเก็บรวบรวมขยะและวิธีการทำงานของการอ้างอิง - อีกครั้งฉันดูคุณบทที่ 7 ของ e-book นอกจากนี้ควรระวังข้อผิดพลาดทั่วไปซึ่งอาจเป็นเหตุการณ์ที่พบบ่อยที่สุด ถ้าวัตถุมีการลงทะเบียนกับเหตุการณ์บนวัตถุBแล้ววัตถุจะติดรอบจนกว่าวัตถุBหายไปเพราะBถืออ้างอิงถึง ทางออกคือการยกเลิกการลงทะเบียนกิจกรรมของคุณเมื่อคุณทำเสร็จแล้ว
แน่นอนโปรไฟล์หน่วยความจำที่ดีจะช่วยให้คุณดูกราฟวัตถุของคุณและสำรวจการทำรัง / อ้างอิงของวัตถุของคุณเพื่อดูว่าอ้างอิงมาจากและสิ่งที่วัตถุรากเป็นผู้รับผิดชอบ ( รายละเอียดสีแดงประตูมด , JetBrains dotMemory, memprofilerดีจริงๆ ตัวเลือกหรือคุณสามารถใช้WinDbgและSOSแบบข้อความอย่างเดียวแต่ฉันขอแนะนำผลิตภัณฑ์เชิงพาณิชย์ / ภาพเว้นแต่คุณเป็นกูรูตัวจริง)
ฉันเชื่อว่ารหัสที่ไม่มีการจัดการอยู่ภายใต้การรั่วไหลของหน่วยความจำทั่วไปยกเว้นว่าการอ้างอิงที่ใช้ร่วมกันจะได้รับการจัดการโดยตัวรวบรวมขยะ ฉันอาจจะผิดเกี่ยวกับจุดสุดท้ายนี้
พูดอย่างเคร่งครัดหน่วยความจำรั่วใช้หน่วยความจำที่ "ไม่ได้ใช้" โดยโปรแกรม
"ไม่ได้ใช้แล้ว" มีความหมายมากกว่าหนึ่งความหมายอาจหมายถึง "ไม่มีการอ้างอิงถึงอีกต่อไป" นั่นคือไม่สามารถกู้คืนได้ทั้งหมดหรืออาจหมายถึงอ้างอิงอ้างอิงคืนได้ไม่ได้ใช้ แต่โปรแกรมยังคงอ้างอิงอยู่ เพียง แต่ต่อมานำไปใช้ NET สำหรับวัตถุที่มีการจัดการที่ดีเลิศ อย่างไรก็ตามคลาสทั้งหมดนั้นไม่สมบูรณ์แบบและในบางจุดการใช้งานที่ไม่มีการจัดการพื้นฐานอาจทำให้ทรัพยากรรั่วไหลอย่างถาวรสำหรับกระบวนการนั้น
ในทุกกรณีแอปพลิเคชันจะใช้หน่วยความจำมากกว่าที่จำเป็นอย่างเคร่งครัด ผลข้างเคียงขึ้นอยู่กับจำนวนกระสุนที่รั่วไหลออกไปจากที่ใดเพื่อชะลอตัวที่เกิดจากการสะสมมากเกินไปไปยังชุดของข้อยกเว้นหน่วยความจำและในที่สุดก็เกิดข้อผิดพลาดร้ายแรงตามด้วยการยุติกระบวนการบังคับ
คุณจะรู้ว่าเป็นโปรแกรมที่มีปัญหาหน่วยความจำเมื่อตรวจสอบแสดงให้เห็นว่ามากขึ้นและหน่วยความจำเพิ่มเติมจะจัดสรรให้กระบวนการของคุณหลังจากที่แต่ละรอบการเก็บขยะ ในกรณีเช่นนี้คุณกำลังเก็บหน่วยความจำมากเกินไปหรือการใช้งานที่ไม่มีการจัดการบางอย่างกำลังรั่ว
สำหรับการรั่วไหลส่วนใหญ่ทรัพยากรจะถูกกู้คืนเมื่อกระบวนการยุติลงอย่างไรก็ตามทรัพยากรบางอย่างจะไม่ถูกกู้คืนในบางกรณีที่แน่นอนเคอร์เซอร์ GDI ที่จัดการนั้นไม่เป็นที่รู้จัก แน่นอนถ้าคุณมีกลไกการสื่อสารระหว่างกระบวนการหน่วยความจำที่จัดสรรในกระบวนการอื่นจะไม่ถูกทำให้เป็นอิสระจนกว่ากระบวนการนั้นจะทำให้เป็นอิสระหรือถูกยกเลิก
ฉันคิดว่าคำถาม "อะไรคือความจำรั่ว" และ "คำตอบเอฟเฟ็กต์อะไร" ได้รับการตอบรับเป็นอย่างดีอยู่แล้ว แต่ฉันต้องการเพิ่มอีกสองสามข้อในคำถามอื่น ...
วิธีทำความเข้าใจว่าแอปพลิเคชันของคุณรั่วหรือไม่
วิธีหนึ่งที่น่าสนใจคือการเปิดperfmonและเพิ่มการติดตามสำหรับ# bytes ใน heap ทั้งหมดและคอลเลกชัน # Gen 2ในแต่ละกรณีดูกระบวนการของคุณ หากการออกกำลังกายคุณสมบัติเฉพาะทำให้จำนวนไบต์ทั้งหมดเพิ่มขึ้นและหน่วยความจำนั้นยังคงถูกจัดสรรหลังจากคอลเล็กชัน Gen 2 ถัดไปคุณอาจกล่าวได้ว่าคุณลักษณะดังกล่าวรั่วหน่วยความจำ
วิธีป้องกัน
มีความคิดเห็นที่ดีอื่น ๆ ฉันเพิ่งจะเพิ่มว่าบางทีสาเหตุที่พบบ่อยที่สุดของการรั่วไหลของหน่วยความจำ. NET คือการเพิ่มตัวจัดการเหตุการณ์ให้กับวัตถุโดยไม่ลบออก ตัวจัดการเหตุการณ์ที่แนบกับวัตถุนั้นเป็นรูปแบบหนึ่งของการอ้างอิงไปยังวัตถุนั้นดังนั้นจะป้องกันการเก็บรวบรวมแม้ว่าการอ้างอิงอื่น ๆ ทั้งหมดจะหายไป อย่าลืมถอดตัวจัดการเหตุการณ์ (ใช้-=ไวยากรณ์ใน C #) เสมอ
การรั่วไหลหายไปเมื่อกระบวนการออกไปและสิ่งที่เกี่ยวกับ COM interop หรือไม่
เมื่อกระบวนการของคุณออกหน่วยความจำทั้งหมดที่แมปลงในพื้นที่ที่อยู่จะถูกเรียกคืนโดยระบบปฏิบัติการรวมถึงวัตถุ COM ใด ๆ ที่ให้บริการจาก DLLs วัตถุ COM นั้นสามารถให้บริการได้น้อยมากเมื่อเทียบกับกระบวนการอื่น ในกรณีนี้เมื่อกระบวนการของคุณออกคุณอาจยังต้องรับผิดชอบหน่วยความจำที่จัดสรรในกระบวนการเซิร์ฟเวอร์ COM ใด ๆ ที่คุณใช้
ฉันจะกำหนดการรั่วไหลของหน่วยความจำเป็นวัตถุที่ไม่ได้เพิ่มหน่วยความจำทั้งหมดที่จัดสรรหลังจากเสร็จสิ้น ฉันพบว่าสิ่งนี้สามารถเกิดขึ้นได้ในแอปพลิเคชันของคุณหากคุณใช้ Windows API และ COM (เช่นรหัสที่ไม่มีการจัดการที่มีจุดบกพร่องหรือมีการจัดการอย่างไม่ถูกต้อง) ในกรอบงานและส่วนประกอบของบุคคลที่สาม ฉันยังพบว่าไม่ได้ซ่อนตัวหลังจากใช้วัตถุบางอย่างเช่นปากกาอาจทำให้เกิดปัญหา
ฉันเองประสบข้อยกเว้นหน่วยความจำไม่เพียงพอซึ่งสามารถเกิดขึ้นได้ แต่ไม่ได้ จำกัด เฉพาะการรั่วไหลของหน่วยความจำในแอ็พพลิเคชัน dot net (OOM อาจมาจากการปักดูการปักหมุด ) หากคุณไม่ได้รับข้อผิดพลาด OOM หรือจำเป็นต้องยืนยันว่าเป็นหน่วยความจำรั่วทำให้เกิดวิธีเดียวที่จะโปรไฟล์แอปพลิเคชันของคุณ
ฉันก็จะพยายามและมั่นใจในสิ่งต่อไปนี้:
a) ทุกอย่างที่ใช้ Idisposable ถูกกำจัดอย่างใดอย่างหนึ่งโดยใช้บล็อกในที่สุดหรือคำสั่งการใช้เหล่านี้รวมถึงแปรงปากกา ฯลฯ (บางคนโต้แย้งที่จะตั้งค่าทุกอย่างเพื่ออะไรเพิ่มเติม)
b) สิ่งใดก็ตามที่มีวิธีการปิดถูกปิดอีกครั้งโดยใช้ในที่สุดหรือคำสั่งการใช้ (แม้ว่าฉันได้พบการใช้ไม่ได้ปิดเสมอไปขึ้นอยู่กับว่าคุณประกาศวัตถุนอกคำสั่งการใช้)
c) หากคุณใช้โค้ด / windows API ที่ไม่มีการจัดการซึ่งสิ่งเหล่านี้จะได้รับการจัดการอย่างถูกต้องหลังจากนั้น (บางคนมีวิธีการล้างข้อมูลเพื่อปล่อยทรัพยากร)
หวังว่านี่จะช่วยได้
หากคุณต้องการวินิจฉัยหน่วยความจำรั่วใน. NET ให้ตรวจสอบลิงค์เหล่านี้:
http://msdn.microsoft.com/en-us/magazine/cc163833.aspx
http://msdn.microsoft.com/en-us/magazine/cc164138.aspx
บทความเหล่านี้อธิบายวิธีการสร้างการถ่ายโอนข้อมูลหน่วยความจำของกระบวนการของคุณและวิธีการวิเคราะห์เพื่อให้คุณสามารถตรวจสอบก่อนว่าการรั่วไหลของคุณไม่มีการจัดการหรือการจัดการและหากมีการจัดการวิธีการคิดออกว่ามาจากไหน
Microsoft ยังมีเครื่องมือที่ใหม่กว่าเพื่อช่วยในการสร้างความผิดพลาดจากการทิ้งเพื่อแทนที่ ADPlus ที่เรียกว่า DebugDiag
การใช้ตัวสร้างโปรไฟล์ CLR จาก Microsoft http://www.microsoft.com/downloads/details.aspx?familyid=86ce6052-d7f4-4aeb-9b7a-94635beebdda&displaylang=thเป็นวิธีที่ดีในการกำหนดว่าวัตถุใดที่มีหน่วยความจำ เพื่อการสร้างวัตถุเหล่านี้และตรวจสอบว่าวัตถุใดอาศัยอยู่ที่ไหนในกอง (การกระจายตัว, LOH, ฯลฯ )
คำอธิบายที่ดีที่สุดเกี่ยวกับวิธีการทำงานของตัวเก็บขยะใน Jeff Richters CLR ผ่านหนังสือC # (Ch. 20) การอ่านสิ่งนี้จะช่วยให้เข้าใจได้ดีว่าวัตถุยังคงอยู่
หนึ่งในสาเหตุที่พบบ่อยที่สุดของการรูทวัตถุโดยไม่ตั้งใจคือการต่อเหตุการณ์นอกชั้นเรียน หากคุณขอเหตุการณ์ภายนอก
เช่น
SomeExternalClass.Changed += new EventHandler(HandleIt);และลืมที่จะปลดล็อคเมื่อคุณทิ้งจากนั้น SomeExternalClass จะมีการอ้างอิงถึงคลาสของคุณ
ดังที่กล่าวไว้ข้างต้นโปรไฟล์หน่วยความจำ SciTechเป็นเลิศในการแสดงรากของวัตถุที่คุณสงสัยว่ามีการรั่วไหล
แต่ยังมีวิธีที่รวดเร็วมากในการตรวจสอบประเภทเฉพาะคือใช้ WnDBG (คุณสามารถใช้สิ่งนี้ในหน้าต่างทันที VS.NET ขณะที่แนบ):
.loadby sos mscorwks
!dumpheap -stat -type <TypeName>ตอนนี้ทำสิ่งที่คุณคิดว่าจะกำจัดวัตถุประเภทนั้น (เช่นปิดหน้าต่าง) มีประโยชน์ที่นี่เพื่อมีปุ่มดีบั๊กที่จะทำงานSystem.GC.Collect()สองสามครั้ง
จากนั้นเรียกใช้!dumpheap -stat -type <TypeName>อีกครั้ง หากจำนวนไม่ลดลงหรือไม่ลดลงตามที่คุณคาดไว้คุณมีพื้นฐานสำหรับการตรวจสอบเพิ่มเติม (ฉันได้รับเคล็ดลับนี้จากการสัมมนาที่ได้รับจากIngo Rammer )
ฉันเดาว่าในสภาพแวดล้อมที่มีการจัดการการรั่วไหลจะทำให้คุณมีการอ้างอิงที่ไม่จำเป็นกับหน่วยความจำขนาดใหญ่
เหตุใดผู้คนจึงคิดว่าหน่วยความจำรั่วใน. NET ไม่เหมือนกับการรั่วไหลอื่น ๆ
หน่วยความจำรั่วคือเมื่อคุณแนบกับทรัพยากรและอย่าปล่อยให้มันไป คุณสามารถทำได้ทั้งในการจัดการและในการเข้ารหัสที่ไม่มีการจัดการ
เกี่ยวกับ. NET และเครื่องมือการเขียนโปรแกรมอื่น ๆ มีความคิดเกี่ยวกับการรวบรวมขยะและวิธีการอื่น ๆ ในการลดสถานการณ์ที่จะทำให้แอปพลิเคชันของคุณรั่วไหล แต่วิธีที่ดีที่สุดในการป้องกันการรั่วไหลของหน่วยความจำคือคุณต้องเข้าใจรูปแบบหน่วยความจำพื้นฐานของคุณและวิธีการทำงานต่าง ๆ บนแพลตฟอร์มที่คุณใช้งานอยู่
การเชื่อว่า GC และเวทมนต์อื่น ๆ จะทำความสะอาดความยุ่งเหยิงของคุณเป็นหนทางสั้น ๆ ในการจำการรั่วไหลและจะหาได้ยากในภายหลัง
เมื่อการเข้ารหัสที่ไม่มีการจัดการปกติคุณต้องแน่ใจว่าได้ทำการล้างข้อมูลแล้วคุณรู้ว่าทรัพยากรที่คุณใช้จะเป็นความรับผิดชอบของคุณในการล้างข้อมูลไม่ใช่ภารโรง
ใน. NET ในทางกลับกันผู้คนจำนวนมากคิดว่า GC จะล้างทุกอย่าง มันมีบางอย่างสำหรับคุณ แต่คุณต้องแน่ใจว่าเป็นเช่นนั้น .NET ห่อหลายสิ่งหลายอย่างดังนั้นคุณไม่ทราบว่าคุณกำลังเผชิญกับทรัพยากรที่มีการจัดการหรือไม่มีการจัดการหรือไม่และคุณต้องแน่ใจว่าคุณกำลังทำอะไรอยู่ การจัดการแบบอักษรทรัพยากร GDI ไดเรกทอรีที่ใช้งานอยู่ฐานข้อมูล ฯลฯ เป็นสิ่งที่คุณต้องระวัง
ในแง่การจัดการฉันจะใส่คอของฉันในบรรทัดเพื่อบอกว่ามันจะหายไปเมื่อกระบวนการถูกฆ่า / ลบ
ฉันเห็นคนจำนวนมากมีสิ่งนี้และฉันหวังว่ามันจะจบลง คุณไม่สามารถขอให้ผู้ใช้ยกเลิกแอปของคุณเพื่อกำจัดความยุ่งเหยิงของคุณ! ดูเบราว์เซอร์ที่สามารถเป็น IE, FF ฯลฯ จากนั้นเปิดพูด Google Reader ปล่อยให้มันอยู่ได้นานหลายวันแล้วดูว่าเกิดอะไรขึ้น
หากคุณเปิดแท็บอื่นในเบราว์เซอร์ให้ไปที่บางไซต์แล้วปิดแท็บที่โฮสต์หน้าอื่นที่ทำให้เบราว์เซอร์รั่วคุณคิดว่าเบราว์เซอร์จะปล่อยหน่วยความจำหรือไม่ ไม่เช่นนั้นกับ IE ในคอมพิวเตอร์ของฉัน IE จะกินหน่วยความจำ 1 GiB ในเวลาสั้น ๆ (ประมาณ 3-4 วัน) หากฉันใช้ Google Reader นักข่าวบางคนยิ่งแย่ลงไปอีก
ฉันเดาว่าในสภาพแวดล้อมที่มีการจัดการการรั่วไหลจะทำให้คุณมีการอ้างอิงที่ไม่จำเป็นกับหน่วยความจำขนาดใหญ่
อย่างแน่นอน นอกจากนี้การไม่ใช้วิธีการ. ทิ้ง () กับวัตถุที่ใช้แล้วทิ้งตามความเหมาะสมอาจทำให้เกิดการรั่วไหลของ Mem วิธีที่ง่ายที่สุดในการทำเช่นนี้คือการใช้บล็อกเพราะมันจะเรียกใช้. Disis () ที่ท้าย:
StreamReader sr;
using(sr = new StreamReader("somefile.txt"))
{
//do some stuff
}และถ้าคุณสร้างคลาสที่ใช้วัตถุที่ไม่มีการจัดการถ้าคุณไม่ได้ใช้งาน IDisposable อย่างถูกต้องคุณอาจทำให้หน่วยความจำรั่วสำหรับผู้ใช้ชั้นเรียนของคุณ
การรั่วไหลของหน่วยความจำทั้งหมดได้รับการแก้ไขโดยการยกเลิกโปรแกรม
หน่วยความจำรั่วไหลไม่เพียงพอและระบบปฏิบัติการอาจตัดสินใจแก้ไขปัญหาในนามของคุณ
ฉันจะเห็นด้วยกับเบอร์นาร์ดใน. net สิ่งที่ mem รั่วจะเป็น
คุณสามารถโปรไฟล์แอปพลิเคชันของคุณเพื่อดูการใช้หน่วยความจำและตรวจสอบว่าหากการจัดการหน่วยความจำจำนวนมากเมื่อมันไม่ควรคุณอาจบอกว่ามันมีการรั่วไหล
ในแง่การจัดการฉันจะใส่คอของฉันในบรรทัดเพื่อบอกว่ามันจะหายไปเมื่อกระบวนการถูกฆ่า / ลบ
รหัสที่ไม่มีการจัดการคือสัตว์ร้ายของตัวเองและหากมีการรั่วไหลอยู่ภายในมันจะเป็นไปตาม mem มาตรฐาน คำจำกัดความการรั่วไหล
นอกจากนี้โปรดทราบว่า. NET มีสองฮีปหนึ่งคือฮีปวัตถุขนาดใหญ่ ฉันเชื่อว่าวัตถุที่มีขนาดประมาณ 85k หรือมากกว่านั้นวางบนกองนี้ ฮีปนี้มีกฎอายุการใช้งานที่แตกต่างจากฮีปทั่วไป
หากคุณกำลังสร้างโครงสร้างหน่วยความจำขนาดใหญ่ (พจนานุกรมหรือรายการ) ก็ควรระมัดระวังที่จะค้นหาว่ากฎที่แน่นอนคืออะไร
ตราบใดที่เรียกคืนหน่วยความจำเกี่ยวกับการยุติกระบวนการเว้นแต่ว่าคุณกำลังใช้งาน Win98 หรือเทียบเท่ากันทุกอย่างจะถูกปล่อยกลับสู่ระบบปฏิบัติการเมื่อมีการยกเลิก ข้อยกเว้นเพียงอย่างเดียวคือสิ่งที่เปิดข้ามกระบวนการและกระบวนการอื่นยังคงมีทรัพยากรเปิดอยู่
วัตถุ COM อาจเป็นสิ่งที่ยุ่งยาก หากคุณใช้IDisposeรูปแบบเสมอคุณจะปลอดภัย IDisposeแต่ผมเคยทำงานในการประกอบการทำงานร่วมกันไม่กี่คนที่ใช้ กุญแจที่นี่คือการโทรMarshal.ReleaseCOMObjectเมื่อคุณทำเสร็จแล้ว วัตถุ COM ยังคงใช้การนับการอ้างอิง COM มาตรฐาน
ฉันพบ. Net Memory Profilerเป็นความช่วยเหลือที่ดีมากเมื่อค้นหาหน่วยความจำรั่วใน. Net มันไม่ฟรีเหมือน Microsoft CLR Profiler แต่เร็วขึ้นและมากขึ้นตามความคิดเห็นของฉัน
หนึ่งคำจำกัดความคือ: ไม่สามารถปล่อยหน่วยความจำที่ไม่สามารถเข้าถึงได้ซึ่งไม่สามารถจัดสรรให้กับกระบวนการใหม่ได้ในระหว่างการดำเนินการกระบวนการจัดสรร ส่วนใหญ่สามารถรักษาให้หายขาดได้โดยใช้เทคนิค GC หรือตรวจพบโดยเครื่องมืออัตโนมัติ
สำหรับข้อมูลเพิ่มเติมกรุณาเยี่ยมชมhttp://all-about-java-and-weblogic-server.blogspot.in/2014/01/what-is-memory-leak-in-java.html