สมมติว่าฉันมีรหัส C ต่อไปนี้:
int main () {
int *p = malloc(10 * sizeof *p);
*p = 42;
return 0; //Exiting without freeing the allocated memory
}
เมื่อฉันรวบรวมและดำเนินการโปรแกรม C นั้นเช่นหลังจากจัดสรรพื้นที่ในหน่วยความจำแล้วหน่วยความจำที่ฉันจัดสรรจะยังคงได้รับการจัดสรร (กล่าวคือใช้พื้นที่ว่าง) หลังจากที่ฉันออกจากแอปพลิเคชันและกระบวนการสิ้นสุดลงหรือไม่
คำตอบ:
ขึ้นอยู่กับระบบปฏิบัติการ ระบบปฏิบัติการที่ทันสมัย (และหลักทั้งหมด) ส่วนใหญ่จะปล่อยหน่วยความจำที่ไม่ได้ปลดปล่อยโดยโปรแกรมเมื่อสิ้นสุดการทำงาน
การอาศัยสิ่งนี้เป็นการปฏิบัติที่ไม่ดีและเป็นการดีกว่าที่จะปลดปล่อยอย่างชัดเจน ปัญหาไม่ใช่แค่ว่าโค้ดของคุณดูไม่ดี คุณอาจตัดสินใจว่าต้องการรวมโปรแกรมขนาดเล็กของคุณเข้ากับโปรแกรมขนาดใหญ่ที่ใช้งานได้ยาวนาน จากนั้นไม่นานคุณต้องใช้เวลาหลายชั่วโมงในการติดตามการรั่วไหลของหน่วยความจำ
การอาศัยคุณสมบัติของระบบปฏิบัติการยังทำให้โค้ดพกพาได้น้อยลง
โดยทั่วไประบบปฏิบัติการวัตถุประสงค์ทั่วไปที่ทันสมัยทำทำความสะอาดหลังจากกระบวนการสิ้นสุด นี่เป็นสิ่งที่จำเป็นเนื่องจากทางเลือกคือระบบจะสูญเสียทรัพยากรเมื่อเวลาผ่านไปและจำเป็นต้องรีบูตเนื่องจากโปรแกรมที่เขียนไม่ดีหรือมีข้อบกพร่องที่ไม่ค่อยเกิดขึ้นซึ่งทำให้ทรัพยากรรั่วไหล
การให้โปรแกรมของคุณว่างทรัพยากรอย่างชัดเจนต่อไปอาจเป็นแนวทางปฏิบัติที่ดีด้วยเหตุผลหลายประการเช่น:
แต่ที่นี่คือเหตุผลที่จะข้ามพ้นหน่วยความจำ: ปิดมีประสิทธิภาพ ตัวอย่างเช่นสมมติว่าแอปพลิเคชันของคุณมีแคชขนาดใหญ่ในหน่วยความจำ หากเมื่อมันออกจากโครงสร้างแคชทั้งหมดและปล่อยทีละชิ้นแสดงว่าไม่มีจุดประสงค์ที่เป็นประโยชน์และสิ้นเปลืองทรัพยากร โดยเฉพาะอย่างยิ่งให้พิจารณากรณีที่ระบบปฏิบัติการเปลี่ยนหน้าหน่วยความจำที่มีแคชของคุณไปยังดิสก์ ด้วยการเดินโครงสร้างและปล่อยให้เป็นอิสระคุณจะนำหน้าเหล่านั้นกลับเข้าสู่หน่วยความจำทั้งหมดในคราวเดียวเสียเวลาและพลังงานไปมากโดยไม่เกิดประโยชน์จริงและอาจทำให้โปรแกรมอื่น ๆ ในระบบถูกสับเปลี่ยนออกไป!
ตามตัวอย่างที่เกี่ยวข้องมีเซิร์ฟเวอร์ประสิทธิภาพสูงที่ทำงานโดยสร้างกระบวนการสำหรับแต่ละคำขอจากนั้นจึงออกจากระบบเมื่อเสร็จสิ้น ด้วยวิธีนี้พวกเขาไม่จำเป็นต้องติดตามการจัดสรรหน่วยความจำและไม่เคยทำการกำจัดหรือเก็บขยะใด ๆ เลยเนื่องจากทุกอย่างจะหายไปกลับเข้าสู่หน่วยความจำว่างของระบบปฏิบัติการเมื่อสิ้นสุดกระบวนการ (สิ่งเดียวกันนี้สามารถทำได้ภายในกระบวนการโดยใช้ตัวจัดสรรหน่วยความจำที่กำหนดเอง แต่ต้องมีการเขียนโปรแกรมอย่างระมัดระวังโดยพื้นฐานแล้วจะมีแนวคิดเกี่ยวกับ "กระบวนการที่มีน้ำหนักเบา" ในกระบวนการ OS เป็นหลัก)
ขอโทษที่โพสต์นานมากหลังจากโพสต์ล่าสุดในกระทู้นี้
อีกหนึ่งจุด ไม่ใช่ทุกโปรแกรมที่ทำให้ออกอย่างสง่างาม การขัดข้องและ ctrl-C เป็นต้นจะทำให้โปรแกรมออกจากระบบโดยไม่สามารถควบคุมได้ หากระบบปฏิบัติการของคุณไม่ทำให้ฮีปของคุณเป็นอิสระให้ล้างสแต็กลบตัวแปรคงที่ ฯลฯ ในที่สุดคุณจะทำให้ระบบของคุณพังจากการรั่วไหลของหน่วยความจำหรือแย่ลง
ที่น่าสนใจนอกเหนือจากนี้ล่ม / หยุดทำงานใน Ubuntu และฉันสงสัยว่าระบบปฏิบัติการสมัยใหม่อื่น ๆ ทั้งหมดมีปัญหากับทรัพยากรที่ "จัดการ" ซ็อกเก็ตไฟล์อุปกรณ์ ฯลฯ สามารถ "เปิด" ได้เมื่อโปรแกรมสิ้นสุด / ล่ม นอกจากนี้วิธีปฏิบัติที่ดีในการปิดสิ่งใด ๆ ด้วย "ที่จับ" หรือ "ตัวอธิบาย" ซึ่งเป็นส่วนหนึ่งของการทำความสะอาดของคุณก่อนออกอย่างสง่า
ฉันกำลังพัฒนาโปรแกรมที่ใช้ซ็อกเก็ตอย่างหนัก เมื่อฉันติดอยู่ในแฮงค์ฉันต้อง ctrl-c จากมันดังนั้นการควั่นซ็อกเก็ตของฉัน ฉันเพิ่ม std :: vector เพื่อรวบรวมรายการซ็อกเก็ตที่เปิดทั้งหมดและตัวจัดการ sigaction ที่จับ sigint และ sigterm ตัวจัดการจะเดินรายการและปิดซ็อกเก็ต ฉันวางแผนที่จะสร้างขั้นตอนการล้างข้อมูลที่คล้ายกันเพื่อใช้ก่อนที่จะโยนซึ่งจะนำไปสู่การยุติก่อนกำหนด
ใครสนใจที่จะแสดงความคิดเห็นเกี่ยวกับการออกแบบนี้?
สิ่งที่เกิดขึ้นที่นี่ ( ในระบบปฏิบัติการสมัยใหม่ ) คือโปรแกรมของคุณทำงานภายใน "กระบวนการ" ของตัวเอง นี่คือเอนทิตีระบบปฏิบัติการที่มีพื้นที่แอดเดรสของตัวเองตัวอธิบายไฟล์ ฯลฯ การmallocโทรของคุณกำลังจัดสรรหน่วยความจำจาก "ฮีป" หรือเพจหน่วยความจำที่ไม่ได้ปันส่วนที่กำหนดให้กับกระบวนการของคุณ
เมื่อโปรแกรมของคุณสิ้นสุดลงดังตัวอย่างนี้ทรัพยากรทั้งหมดที่กำหนดให้กับกระบวนการของคุณจะถูกนำกลับมาใช้ใหม่ / ฉีกทิ้งโดยระบบปฏิบัติการ ในกรณีของหน่วยความจำเพจหน่วยความจำทั้งหมดที่กำหนดให้คุณจะถูกทำเครื่องหมายว่า "ว่าง" และนำไปรีไซเคิลเพื่อใช้ในกระบวนการอื่น ๆ Pages เป็นแนวคิดระดับล่างกว่าที่ malloc จัดการด้วยเหตุนี้ความเฉพาะเจาะจงของ malloc / free จึงถูกชะล้างออกไปเมื่อทุกสิ่งได้รับการทำความสะอาด
เป็นคุณธรรมที่เทียบเท่าเมื่อคุณใช้แล็ปท็อปของคุณเสร็จแล้วและต้องการมอบให้เพื่อนคุณไม่ต้องกังวลกับการลบทีละไฟล์ คุณเพียงแค่ฟอร์แมตฮาร์ดไดรฟ์
สิ่งที่กล่าวมาทั้งหมดนี้เนื่องจากผู้ตอบรายอื่นทั้งหมดสังเกตว่าการอาศัยสิ่งนี้ไม่ใช่แนวทางปฏิบัติที่ดี:
ใช่. ระบบปฏิบัติการล้างทรัพยากร ดี ... NetWare เวอร์ชันเก่าไม่มี
แก้ไข: ดังที่ San Jacinto ชี้ให้เห็นว่ามีระบบ (นอกเหนือจาก NetWare) ที่ไม่ทำเช่นนั้น แม้จะอยู่ในโปรแกรมแบบทิ้งฉันก็พยายามสร้างนิสัยในการปลดปล่อยทรัพยากรทั้งหมดเพียงเพื่อให้เป็นนิสัย
ใช่ระบบปฏิบัติการจะปล่อยหน่วยความจำทั้งหมดเมื่อกระบวนการสิ้นสุดลง
malloc
ขึ้นอยู่กับว่าระบบปฏิบัติการมักจะล้างข้อมูลให้คุณ แต่ถ้าคุณกำลังทำงานกับซอฟต์แวร์ฝังตัวเช่นซอฟต์แวร์นั้นอาจไม่ถูกปล่อยออกมา
เพียงตรวจสอบให้แน่ใจว่าคุณว่างมันจะช่วยให้คุณประหยัดเวลาได้มากในภายหลังเมื่อคุณอาจต้องการรวมเข้ากับโครงการขนาดใหญ่
ขึ้นอยู่กับระบบปฏิบัติการจริง ๆ แต่สำหรับระบบปฏิบัติการทั้งหมดที่คุณเคยพบการจัดสรรหน่วยความจำจะหายไปเมื่อกระบวนการออก
ฉันคิดว่าการปลดปล่อยโดยตรงดีที่สุด พฤติกรรมที่ไม่ได้กำหนดเป็นสิ่งที่แย่ที่สุดดังนั้นหากคุณสามารถเข้าถึงได้ในขณะที่ยังคงกำหนดอยู่ในกระบวนการของคุณให้ทำมันมีเหตุผลดีๆมากมายที่ผู้คนให้ไว้
ว่าอยู่ที่ไหนหรือว่าฉันพบว่าใน W98 คำถามที่แท้จริงคือ 'เมื่อไหร่' (ฉันไม่เห็นโพสต์ที่เน้นเรื่องนี้) โปรแกรมเทมเพลตขนาดเล็ก (สำหรับการป้อนข้อมูล MIDI SysEx โดยใช้ช่องว่าง malloc ต่างๆ) จะทำให้หน่วยความจำว่างในบิต WM_DESTROY ของ WndProc แต่เมื่อฉันย้ายสิ่งนี้ไปยังโปรแกรมที่ใหญ่กว่ามันจะล้มเหลวเมื่อออก ฉันคิดว่านี่หมายความว่าฉันกำลังพยายามปลดปล่อยสิ่งที่ระบบปฏิบัติการได้ปลดปล่อยไปแล้วในระหว่างการล้างข้อมูลขนาดใหญ่ ถ้าฉันทำบน WM_CLOSE แล้วเรียกว่า DestroyWindow () ทุกอย่างทำงานได้ดีออกทันที
แม้ว่าสิ่งนี้จะไม่เหมือนกับบัฟเฟอร์ MIDI แต่ก็มีความคล้ายคลึงกันที่ดีที่สุดคือทำให้กระบวนการเหมือนเดิมล้างข้อมูลทั้งหมดแล้วออก ด้วยหน่วยความจำที่เรียบง่ายทำให้เร็วมาก ฉันพบว่าบัฟเฟอร์ขนาดเล็กจำนวนมากทำงานได้เร็วขึ้นในการทำงานและการล้างข้อมูลมากกว่าบัฟเฟอร์ขนาดใหญ่น้อยกว่า
อาจมีข้อยกเว้นตามที่ใครบางคนกล่าวไว้เมื่อหลีกเลี่ยงการดึงชิ้นส่วนหน่วยความจำขนาดใหญ่กลับออกจากไฟล์ swap บนดิสก์ แต่ถึงอย่างนั้นก็อาจถูกย่อให้เล็กลงด้วยการทำให้พื้นที่จัดสรรมากขึ้นและเล็กลง