Wie Schließungen zu Speicherverlusten führen können und was Sie dagegen tun können

Einführung

Speicherlecks sind der Albtraum eines Entwicklers, insbesondere wenn sie in der Produktion auftreten. Trotz unserer besten Bemühungen, sauberen, effizienten Code zu schreiben, können subtile Probleme wie die unsachgemäße Verwendung von Abschlüssen zu Speicherlecks führen, die schwer zu erkennen und zu beheben sind. Dieser Artikel konzentriert sich auf das Verständnis von Schließungen und ihrer Interaktion mit dem Garbage Collector (GC) und schildert meine Erfahrungen mit einem versehentlichen Speicherverlust, der durch Schließungen verursacht wurde. Wir werden untersuchen, wie Abschlüsse Verweise auf das Gedächtnis enthalten, warum dies den GC daran hindern kann, es zurückzugewinnen, und welche Lehren wir dabei ziehen.

Das Problem: Eine allmähliche Speichersteigerung in der Produktion

Bei der Entwicklung und beim Testen schien alles in Ordnung zu sein. Einige Tage nach der Bereitstellung unserer Anwendung in der Produktion meldete unser Überwachungssystem jedoch ein ungewöhnliches Speichernutzungsmuster. Der Speicherverbrauch unserer Node.js-Anwendung nahm im Laufe der Zeit stetig zu, was schließlich zu Leistungseinbußen und sogar Abstürzen führte.

Anfangs vermutete ich externe Faktoren, wie etwa Probleme mit der Datenbankverbindung oder nicht optimierte Bibliotheken von Drittanbietern. Aber nachdem ich die Anwendung isoliert und das Problem lokal reproduziert hatte, wurde mir klar, dass das Problem in unserer Codebasis lag.

Die Untersuchung: Ein herausfordernder Weg

1. Abschlüsse und den Garbage Collector verstehen

Abschlüsse sind Funktionen, die ihren lexikalischen Geltungsbereich „schließen“ und dabei Verweise auf Variablen beibehalten, die in ihrem äußeren Geltungsbereich definiert sind. Obwohl dieses Verhalten unglaublich wirkungsvoll ist, kann es zu Speicherverlusten führen, wenn Entwickler nicht wissen, welche Variablen der Abschluss festhält. Der Garbage Collector kann keinen Speicher für Variablen freigeben, auf die durch Abschlüsse verwiesen wird, selbst wenn diese Variablen an anderer Stelle in der Anwendung nicht mehr benötigt werden.

2. Analyse der Symptome

Speicherlecks äußern sich häufig darin, dass Speicher nicht mehr benötigt, aber nicht freigegeben wird. In diesem Fall konnte der Garbage Collector keinen Speicher zurückgewinnen, was darauf hindeutet, dass etwas in unserem Code Verweise auf nicht verwendete Objekte behielt. Die Herausforderung bestand darin, herauszufinden, was.

3. Analysieren des Heaps

Ich habe mich an Node.js Heap Snapshots gewandt, um die Speichernutzung zu erfassen und zu analysieren. Indem ich in verschiedenen Abständen Schnappschüsse des Haufens machte, beobachtete ich Folgendes:

• Eine wachsende Zahl aufbewahrter Objekte.
• Bestimmte Abschlüsse enthalten Verweise auf Variablen, lange nachdem ihre Nützlichkeit beendet war.

4. Der Übeltäter: Ein Verschluss mit großen Datenmengen

Nachdem ich die Heap-Analyse sorgfältig durchgegangen war, stellte ich fest, dass ein Abschluss unbeabsichtigt Verweise auf Variablen in seinem äußeren Bereich festhielt und so verhinderte, dass sie durch den Müll gesammelt werden. Dieser Verschluss wurde unbeabsichtigt am Leben gehalten und verhinderte so, dass der Garbage Collector den mit dem großen Objekt verbundenen Speicher zurückgewinnen konnte.

Hier ist ein konkretes Beispiel:

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.

Was im Code passiert:

1. Erstellung eines großen Objekts:
   Innerhalb von createLeak wird ein großes Array „largeObject“ erstellt. Dieses Array verbraucht viel Speicher.

2. Closure Retains Reference:
   Die innere Funktion „leakyFunction“ bildet einen Abschluss über dem Bereich der äußeren Funktion, der die Variable „largeObject“ enthält.

3. Rückkehr der Schließung:
   Der Verschluss „leakyFunction“ wird zurückgegeben und „leakyClosure.

“ zugewiesen

4. Speicherleck:
   Auch wenn „createLeak“ die Ausführung abschließt, wird das „largeObject“ nicht durch Garbage Collection erfasst, da die „closure“-Funktion „leakyFunction“ immer noch einen Verweis darauf enthält.

Dadurch wird verhindert, dass das largeObject aus dem Speicher freigegeben wird.

Die Lösung: Das Leck beheben

Um das Problem zu beheben, habe ich den Code neu gestaltet, um sicherzustellen, dass Abschlüsse keine unnötigen Verweise auf große Objekte beibehalten. Die Lösung stellt sicher, dass Abschlüsse nur Verweise auf notwendige Variablen behalten. Hier ist das überarbeitete Beispiel:

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.

Was sich geändert hat:

• Nur ​​der notwendige Teil des largeObject (importantValue) bleibt im Abschluss erhalten.
• Das große Array „largeObject“ wird durch den Abschluss nicht mehr referenziert, sodass der Garbage Collector seinen Speicher freigeben kann, sobald „createFixed“ die Ausführung abgeschlossen hat.

Gelernte Lektionen

Diese Erfahrung hat mir mehrere wertvolle Lektionen über Schließungen und Gedächtnismanagement beigebracht:

1. Abschlüsse und den Garbage Collector verstehen:

   • Abschlüsse behalten Verweise auf Variablen in ihrem äußeren Gültigkeitsbereich. Wenn diese Verweise nicht mehr benötigt, aber nicht explizit freigegeben werden, kann der Garbage Collector den zugehörigen Speicher nicht zurückgewinnen, was zu Lecks führt.

2. Produktionsanwendungen überwachen:

   • Richten Sie eine robuste Überwachung ein, um Speicheranomalien frühzeitig zu erkennen. Speicherlecks manifestieren sich oft schleichend, sodass die Überwachung von Trends dabei helfen kann, Probleme zu erkennen, bevor sie kritisch werden.

3. Erfasste Variablen minimieren:

   • Entwerfen Sie Abschlüsse so, dass sie nur die Variablen erfassen, die sie wirklich benötigen, und verringern Sie so die Wahrscheinlichkeit, unnötige Daten aufzubewahren.

Abschluss

Speicherlecks können schwer zu erkennen sein, insbesondere wenn sie durch subtile Probleme wie Schließungen verursacht werden. Um effizienten und leckagefreien Code zu schreiben, ist es wichtig zu verstehen, wie Abschlüsse mit dem Garbage Collector interagieren. Mit den richtigen Tools und Praktiken können solche Lecks effektiv identifiziert und behoben werden. Indem Sie bei der Bereinigung von Ressourcen wachsam sind und darauf achten, welche Schließungen erfasst werden, können Sie ähnliche Fallstricke vermeiden und sicherstellen, dass Ihre Anwendungen in der Produktion reibungslos laufen.

Das obige ist der detaillierte Inhalt vonWie Schließungen zu Speicherverlusten führen können und was Sie dagegen tun können. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!