Bagaimana Penutupan Boleh Menyebabkan Kebocoran Memori dan Perkara yang Boleh Anda Lakukan Mengenainya

pengenalan

Kebocoran memori adalah mimpi ngeri pembangun, terutamanya apabila ia berlaku dalam pengeluaran. Walaupun usaha terbaik kami untuk menulis kod yang bersih dan cekap, isu halus seperti penggunaan penutupan yang tidak betul boleh menyebabkan kebocoran memori yang sukar dikesan dan diselesaikan. Artikel ini memfokuskan pada memahami penutupan dan interaksi mereka dengan pemungut sampah (GC), menceritakan pengalaman saya dengan kebocoran ingatan secara tidak sengaja yang disebabkan oleh penutupan. Kami akan meneroka cara penutupan memegang rujukan kepada ingatan, sebab ini boleh menghalang GC daripada menuntut semula dan pengajaran yang dipelajari sepanjang perjalanan.

Masalahnya: Peningkatan Memori Secara Berperingkat dalam Pengeluaran

Semuanya kelihatan baik semasa pembangunan dan ujian. Walau bagaimanapun, beberapa hari selepas menggunakan aplikasi kami ke pengeluaran, sistem pemantauan kami menandakan corak penggunaan memori yang luar biasa. Penggunaan memori aplikasi Node.js kami semakin meningkat dari semasa ke semasa, akhirnya menyebabkan kemerosotan prestasi dan juga ranap.

Pada mulanya, saya mengesyaki faktor luaran, seperti isu sambungan pangkalan data atau perpustakaan pihak ketiga yang tidak dioptimumkan. Tetapi selepas mengasingkan aplikasi dan mengeluarkan semula isu itu secara tempatan, saya menyedari masalah itu berada dalam pangkalan kod kami.

Siasatan: Laluan yang Mencabar

1. Memahami Penutupan dan Pemungut Sampah

Penutupan ialah fungsi yang "menutup" skop leksikalnya, mengekalkan rujukan kepada pembolehubah yang ditakrifkan dalam skop luarnya. Walaupun tingkah laku ini sangat berkuasa, ia boleh menyebabkan kebocoran memori jika pembangun tidak mengetahui pembolehubah yang dipegang oleh penutupan itu. Pengumpul sampah tidak boleh melepaskan memori untuk pembolehubah yang dirujuk oleh penutupan, walaupun pembolehubah tersebut tidak lagi diperlukan di tempat lain dalam aplikasi.

2. Menganalisis Gejala

Kebocoran memori selalunya nyata sebagai ingatan yang tidak lagi diperlukan tetapi tidak dikeluarkan. Dalam kes ini, pemungut sampah tidak dapat menuntut semula memori, menunjukkan bahawa sesuatu dalam kod kami mengekalkan rujukan kepada objek yang tidak digunakan. Cabarannya ialah mengenal pasti apa.

3. Menganalisis Timbunan

Saya beralih kepada Syot Kilat Node.js Heap untuk menangkap dan menganalisis penggunaan memori. Dengan mengambil gambar timbunan pada selang masa yang berbeza, saya memerhati:

• Semakin banyak objek yang dikekalkan.
• Penutupan tertentu memegang rujukan kepada pembolehubah lama selepas kegunaannya telah tamat.

4. Penyebabnya: Penutupan Memegang Data Besar

Setelah meneliti analisis timbunan dengan teliti, saya mendapati bahawa penutupan secara tidak sengaja memegang rujukan kepada pembolehubah dalam skop luarnya, menghalangnya daripada dikumpul sampah. Penutupan ini secara tidak sengaja terus hidup, menghalang pemungut sampah daripada menuntut semula ingatan yang dikaitkan dengan objek besar itu.

Berikut ialah contoh konkrit:

function createLeak() {
    const largeObject = new Array(1000000).fill('leaky data'); // Simulating a large object.

    // The closure retains a reference to `largeObject`.
    return function leakyFunction() {
        console.log(largeObject[0]); // Accessing `largeObject` in the closure.
    };
}

const leakyClosure = createLeak();
// Even if `createLeak` is no longer called, `largeObject` remains in memory due to the closure.

Apa yang Berlaku dalam Kod:

1. Penciptaan largeObject:
   Di dalam createLeak, array besar largeObject dicipta. Tatasusunan ini menggunakan sejumlah besar memori.

2. Penutupan Mengekalkan Rujukan:
   Fungsi dalaman leakyFunction membentuk penutupan ke atas skop fungsi luar, yang termasuk pembolehubah largeObject.

3. Pemulangan Penutupan:
   Penutupan leakyFunction dikembalikan dan diberikan kepada leakyClosure.

4. Kebocoran Ingatan:
   Walaupun createLeak menyelesaikan pelaksanaan, largeObject bukanlah sampah yang dikumpul kerana penutupan leakyFunction masih memegang rujukan kepadanya.

Ini menghalang largeObject daripada dibebaskan daripada ingatan.

Penyelesaian: Membaiki Kebocoran

Untuk menyelesaikan isu ini, saya mereka bentuk semula kod untuk memastikan penutupan tidak mengekalkan rujukan yang tidak perlu kepada objek besar. Penyelesaian memastikan penutupan hanya mengekalkan rujukan kepada pembolehubah yang diperlukan. Berikut ialah contoh yang disemak:

function createFixed() {
    const largeObject = new Array(1000000).fill('leaky data');

    // Use the required value, not the entire object.
    const importantValue = largeObject[0];

    // Only keep the necessary data in the closure.
    return function fixedFunction() {
        console.log(importantValue);
    };
}

const fixedClosure = createFixed();
// Now, `largeObject` can be garbage collected since the closure does not retain it.

Perkara yang Berubah:

• Hanya bahagian yang diperlukan dari largeObject (Nilai Penting) dikekalkan dalam penutupan.
• Tatasusunan besar largeObject tidak lagi dirujuk oleh penutupan, membenarkan pemungut sampah membebaskan ingatannya sebaik sahaja createFixed selesai pelaksanaan.

Pengajaran

Pengalaman ini mengajar saya beberapa pelajaran berharga tentang penutupan dan pengurusan ingatan:

1. Fahami Penutupan dan Pemungut Sampah:

   • Penutupan mengekalkan rujukan kepada pembolehubah dalam skop luarnya. Jika rujukan tersebut tidak lagi diperlukan tetapi tidak dikeluarkan secara jelas, pemungut sampah tidak boleh menuntut semula memori yang berkaitan, yang membawa kepada kebocoran.

2. Aplikasi Pengeluaran Pantau:

   • Sediakan pemantauan yang teguh untuk mengesan anomali ingatan lebih awal. Kebocoran ingatan selalunya nyata secara beransur-ansur, jadi pemantauan arah aliran boleh membantu menangkap isu sebelum ia menjadi kritikal.

3. Minimumkan Pembolehubah Ditangkap:

   • Reka bentuk penutupan untuk menangkap hanya pembolehubah yang benar-benar mereka perlukan, mengurangkan kemungkinan mengekalkan data yang tidak diperlukan.

Kesimpulan

Kebocoran memori mungkin sukar difahami, terutamanya apabila ia disebabkan oleh isu halus seperti penutupan. Memahami cara penutupan berinteraksi dengan pemungut sampah adalah penting untuk menulis kod yang cekap dan bebas kebocoran. Dengan alat dan amalan yang betul, kebocoran tersebut boleh dikenal pasti dan diselesaikan dengan berkesan. Dengan berwaspada tentang membersihkan sumber dan mengambil kira perkara yang ditutup, anda boleh mengelakkan perangkap yang sama dan memastikan aplikasi anda berjalan lancar dalam pengeluaran.

Atas ialah kandungan terperinci Bagaimana Penutupan Boleh Menyebabkan Kebocoran Memori dan Perkara yang Boleh Anda Lakukan Mengenainya. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!