Förstå och förhindra minnesläckor

Delphis stöd för objektorienterad programmering är rikt och kraftfullt. Klasser och objekt möjliggör modulär kodprogrammering. Tillsammans med mer modulära och mer komplexa komponenter kommer mer sofistikerade och mer komplexa buggar.

Även om att utveckla applikationer i Delphi är (nästan) alltid kul, finns det situationer när du känner att hela världen är emot dig.

När du behöver använda (skapa) ett objekt i Delphi måste du frigöra minnet som det konsumerade (en gång inte längre behövs). Visst kan minnesskyddsblocken för försök / slutligen hjälpa dig att förhindra läckage av minnet; det är fortfarande upp till dig att skydda din kod.

Ett minne (eller resurs) läcker uppstår när programmet tappar förmågan att frigöra minnet det förbrukar. Upprepade minnesläckor gör att minnesanvändningen i en process växer utan gränser. Minnesläckor är ett allvarligt problem - om du har en kod som orsakar minnesläcka, i en applikation som kör 24/7, kommer applikationen att äta upp allt tillgängligt minne och slutligen få maskinen att sluta svara.

Memory Läckor i Delphi

Det första steget för att undvika minnesläckor är att förstå hur de uppstår. Följande är en diskussion om några vanliga fallgropar och bästa metoder för att skriva Delphi-kod som inte läcker.

I de flesta (enkla) Delphi-applikationer, där du använder komponenterna (knappar, memo, redigeringar etc.) som du släpper på ett formulär (vid designtid) behöver du inte bry dig för mycket om minneshantering. När komponenten har placerats på ett formulär blir formen dess ägare och kommer att frigöra minnet som tas av komponenten när formuläret har stängts (förstörs). Formuläret är som ägare ansvarigt för minnesfördelning av de komponenter som det är värd. Kort sagt: komponenter i ett formulär skapas och förstörs automatiskt

Exempel på minnesläckor

I alla icke-triviala Delphi-applikationer vill du instansera Delphi-komponenter vid körning. Du kommer också att ha några av dina egna klasser. Låt oss säga att du har en klass TDeveloper som har en metod DoProgram. När du nu vill använda TDeveloper-klassen skapar du en instans av klassen genom att ringa till Skapa metod (konstruktör). Metoden Skapa tilldelar minne för ett nytt objekt och returnerar en referens till objektet.

var
zarko: TDeveloper
Börja
zarko: = TMyObject.Create;
zarko.DoProgram;
slutet;

Och här är en enkel minnesläcka!

Varje gång du skapar ett objekt måste du bortskaffa minnet som det ockuperade. För att frigöra minnet som ett tilldelat objekt måste du ringa till Fri metod. För att vara helt säker bör du också använda try / slutligen blockera:

var
zarko: TDeveloper
Börja
zarko: = TMyObject.Create;
Prova
zarko.DoProgram;
till sist
zarko.Free;
slutet;
slutet;

Detta är ett exempel på säker minnesallokering och deallokaliseringskod.

Några varningsord: Om du vill dynamiskt instansera en Delphi-komponent och uttryckligen frigöra den någon gång senare, passera alltid nil som ägare. Om du inte gör det kan det orsaka onödiga risker samt problem med prestanda och kodunderhåll.

Förutom att skapa och förstöra objekt med hjälp av Create and Free-metoderna, måste du också vara mycket försiktig när du använder "externa" (filer, databaser, etc.) resurser.
Låt oss säga att du måste använda en textfil. I ett mycket enkelt scenario, där AssignFile-metoden används för att associera en fil på en disk med en filvariabel när du är klar med filen, måste du ringa CloseFile för att frigöra filhandtaget för att börja använda. Det är här du inte har ett uttryckligt samtal till "Gratis".

var
F: TextFile;
S: sträng;
Börja
AssignFile (F, 'c: \ somefile.txt');
Prova
Readln (F, S);
till sist
CloseFile (F);
slutet;
slutet;

Ett annat exempel inkluderar inläsning av externa DLL-filer från din kod. När du använder LoadLibrary måste du ringa FreeLibrary:

var
dllHandle: THandle;
Börja
dllHandle: = Loadlibrary ('MyLibrary.DLL');
// gör något med denna DLL
om dllHandle 0, då FreeLibrary (dllHandle);
slutet;

Minnesläckor i .NET?

Även om avfallssamlaren (GC) hanterar de flesta minnesuppgifter med Delphi för .NET, är det möjligt att ha minnesläckor i .NET-applikationer. Här är en artikeldiskussion GC i Delphi för .NET.

Hur man kämpar mot minnesläckor

Förutom att skriva modulär minnesäker kod kan du förhindra läckage av minnet genom att använda några av de tillgängliga tredjepartsverktygen. Delphi Memory Leak Fix-verktyg hjälper dig att fånga Delphi-applikationsfel som minneskorruption, minnesläckor, minnesallokeringsfel, variabla initieringsfel, variabla definitionskonflikter, pekfel och mer.