Registrering af memory leaks med Instruments
Brug Xcode Instruments til at identificere og løse memory leaks, retain cycles og andre hukommelsesrelaterede performanceflaskehalse.
Registrering af memory leaks med Instruments er en gratis Objective-C-udvikling til iOS med ældre og virksomhedsapplikationer-lektion på CoddyKit. Dette er lektion 1 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Objective-C-udvikling til iOS med ældre og virksomhedsapplikationer, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Objective-C-udvikling til iOS med ældre og virksomhedsapplikationer-kurset indeholder 4 lektioner i alt.
Hvad er hukommelseslækager
I Objective-C opstår der en hukommelseslækage, når din app allokerer hukommelse til et objekt, men derefter mister alle referencer til objektet uden at frigive det.
Det betyder, at hukommelsen stadig er optaget, men at din app ikke længere kan tilgå eller frigive den. Med tiden kan lækager gøre din app langsommere og endda få den til at gå ned.
Introduktion til Xcode Instruments
Xcode Instruments er et effektivt værktøj til profilering og analyse fra Apple. Det hjælper udviklere med at forstå deres apps ydeevne på forskellige områder, herunder CPU-forbrug, energiforbrug og især hukommelseshåndtering.
Det er som røntgensyn til din apps indre!
Instrumentet »Leaks«
Blandt sine mange skabeloner tilbyder Instruments et dedikeret »Leaks«-instrument. Værktøjet er specifikt designet til at registrere og visualisere hukommelseslækager i dine Objective-C-applikationer.
Det overvåger hukommelsesallokeringer og -frigivelser og fremhæver objekter, der stadig ligger i hukommelsen, men som ikke længere kan nås.
Profilering af din app for lækager
Følg disse trin for at begynde at registrere lækager:
- 1. Gå i Xcode til Product > Profile.
- 2. Xcode starter Instruments. Vælg skabelonen »Leaks«.
- 3. Klik på knappen »Choose«.
- 4. Klik på knappen »Record« (den røde cirkel) i Instruments for at begynde at køre din app.
Interagér nu med din app for at forsøge at udløse potentielle lækager.
Fortolkning af grafen for lækager
Mens din app kører, viser Instruments en tidslinjegraf. Se efter røde søjler, der vises i sporet »Leaks« – de angiver, at der er registreret en hukommelseslækage på det pågældende tidspunkt.
Søjlens højde hænger ofte sammen med mængden af lækket hukommelse eller antallet af lækkede objekter.
Lokalisering af kilden til lækagen
Sådan finder du ud af, hvor en lækage opstår:
- 1. Vælg en rød søjle (en lækagespids) på tidslinjen.
- 2. Skift til visningen »Call Tree« i detaljeruden nedenfor.
- 3. Se efter metodekald, der er fremhævet med rødt eller lilla. De peger ofte på den kode, der er ansvarlig for at allokere det lækkede objekt.
Kaldstakken hjælper dig med at spore tilbage til den præcise kodelinje!
Almindelig årsag: Retain-cyklusser
En meget almindelig årsag til hukommelseslækager i Objective-C (især med ARC) er en retain-cyklus (også kaldet en cyklus af stærke referencer).
Det sker, når to eller flere objekter har stærke referencer til hinanden og danner en lukket løkke. Fordi hvert objekt tror, at et andet objekt stadig har brug for det, kan ingen af dem frigives, selvom resten af applikationen ikke længere har brug for dem.
Eksempel: En retain-cyklus
Her er et forenklet eksempel på to klasser, MyObject og OtherObject, der opretter en retain-cyklus. Bemærk, at begge egenskaber er strong.
Kør denne kode. Du vil se meddelelser om »initialized«, men ingen meddelelser om »deallocated«, hvilket angiver en lækage.
// MyObject.h
#import <Foundation/Foundation.h>
@class OtherObject;
@interface MyObject : NSObject
@property (strong, nonatomic) OtherObject *other; // Strong reference
- (instancetype)initWithName:(NSString *)name;
@end
// OtherObject.h
#import <Foundation/Foundation.h>
@class MyObject;
@interface OtherObject : NSObject
@property (strong, nonatomic) MyObject *my; // Strong reference
- (instancetype)initWithName:(NSString *)name;
@end
// MyObject.m
#import "MyObject.h"
#import "OtherObject.h"
@interface MyObject ()
@property (strong, nonatomic) NSString *name;
@end
@implementation MyObject
- (instancetype)initWithName:(NSString *)name {
self = [super init];
if (self) {
_name = name;
NSLog(@"MyObject %@ initialized", _name);
}
return self;
}
- (void)dealloc {
NSLog(@"MyObject %@ deallocated", self.name);
}
@end
// OtherObject.m
#import "OtherObject.h"
#import "MyObject.h"
@interface OtherObject ()
@property (strong, nonatomic) NSString *name;
@end
@implementation OtherObject
- (instancetype)initWithName:(NSString *)name {
self = [super init];
if (self) {
_name = name;
NSLog(@"OtherObject %@ initialized", _name);
}
return self;
}
- (void)dealloc {
NSLog(@"OtherObject %@ deallocated", self.name);
}
@end
// main.m
#import <Foundation/Foundation.h>
#import "MyObject.h"
#import "OtherObject.h"
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSLog(@"--- Starting Retain Cycle Demo ---");
MyObject *obj1 = [[MyObject alloc] initWithName:@"Object 1"];
OtherObject *obj2 = [[OtherObject alloc] initWithName:@"Object 2"];
// Create a strong, circular reference
obj1.other = obj2;
obj2.my = obj1;
NSLog(@"Objects created and linked. Notice no dealloc messages will appear.");
}
NSLog(@"--- Retain Cycle Demo Ended ---");
return 0;
}Ophæv retain-cyklusser med 'weak'
For at ophæve en retain-cyklus skal en af referencerne i løkken være 'weak' i stedet for 'strong'. En weak-reference øger ikke et objekts retain-tæller, så objektet kan deallokeres, når der ikke er flere strong-referencer.
Kør dette rettede eksempel. Nu vil du se meddelelserne om 'deallocated', hvilket betyder, at der ikke er noget memory leak!
// MyObject.h
#import <Foundation/Foundation.h>
@class OtherObject;
@interface MyObject : NSObject
@property (strong, nonatomic) OtherObject *other;
- (instancetype)initWithName:(NSString *)name;
@end
// OtherObject.h (FIXED: Using 'weak')
#import <Foundation/Foundation.h>
@class MyObject;
@interface OtherObject : NSObject
@property (weak, nonatomic) MyObject *my; // Weak reference to break the cycle
- (instancetype)initWithName:(NSString *)name;
@end
// MyObject.m
#import "MyObject.h"
#import "OtherObject.h"
@interface MyObject ()
@property (strong, nonatomic) NSString *name;
@end
@implementation MyObject
- (instancetype)initWithName:(NSString *)name {
self = [super init];
if (self) {
_name = name;
NSLog(@"MyObject %@ initialized", _name);
}
return self;
}
- (void)dealloc {
NSLog(@"MyObject %@ deallocated", self.name);
}
@end
// OtherObject.m
#import "OtherObject.h"
#import "MyObject.h"
@interface OtherObject ()
@property (strong, nonatomic) NSString *name;
@end
@implementation OtherObject
- (instancetype)initWithName:(NSString *)name {
self = [super init];
if (self) {
_name = name;
NSLog(@"OtherObject %@ initialized", _name);
}
return self;
}
- (void)dealloc {
NSLog(@"OtherObject %@ deallocated", self.name);
}
@end
// main.m
#import <Foundation/Foundation.h>
#import "MyObject.h"
#import "OtherObject.h"
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSLog(@"--- Starting Fixed Cycle Demo ---");
MyObject *obj1 = [[MyObject alloc] initWithName:@"Object 1"];
OtherObject *obj2 = [[OtherObject alloc] initWithName:@"Object 2"];
// Assign references. obj2 now has a weak ref to obj1.
obj1.other = obj2;
obj2.my = obj1;
NSLog(@"Objects created and linked. Now dealloc messages should appear!");
}
NSLog(@"--- Fixed Cycle Demo Ended ---");
return 0;
}Hurtigt tjek: Find memory leaks
Du har bemærket, at din Objective-C-app bliver langsommere med tiden og bruger mere hukommelse end forventet. Du har mistanke om memory leaks.
Opsummering: Få styr på hukommelsen
Du har lært, at memory leaks forhindrer objekter i at blive deallokeret, hvilket fører til problemer med ydeevnen. Xcode Instruments, især skabelonen 'Leaks', er dit foretrukne værktøj til at identificere disse problemer.
En almindelig årsag er en retain-cyklus, hvor objekter har strong-referencer til hinanden. Du kan ophæve disse cyklusser ved at bruge weak-referencer (@property (weak, nonatomic)) for at sikre korrekt hukommelseshåndtering.
Lær Objective-C med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 12
- Lektioner
- 48
Ofte stillede spørgsmål
Er lektionen “Registrering af memory leaks med Instruments” gratis?
Ja — hele teksten til “Registrering af memory leaks med Instruments” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Objective-C-udvikling til iOS med ældre og virksomhedsapplikationer-kurset, skal du opgradere til CoddyKit PRO. Objective-C-udvikling til iOS med ældre og virksomhedsapplikationer-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “Registrering af memory leaks med Instruments”?
Brug Xcode Instruments til at identificere og løse memory leaks, retain cycles og andre hukommelsesrelaterede performanceflaskehalse. Du øver dig i Objective-C-udvikling til iOS med ældre og virksomhedsapplikationer med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på Objective-C-udvikling til iOS med ældre og virksomhedsapplikationer?
Der kræves ingen tidligere erfaring. Objective-C-udvikling til iOS med ældre og virksomhedsapplikationer på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 4.
Hvor lang tid tager lektionen “Registrering af memory leaks med Instruments”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne Objective-C-udvikling til iOS med ældre og virksomhedsapplikationer-lektion?
Ja. Alle Objective-C-udvikling til iOS med ældre og virksomhedsapplikationer-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- Registrering af memory leaks med Instruments
- Optimering af UI-rendering og reaktionsevne
- Avancerede debuggingteknikker
- Profilering og reduktion af appens opstartstid