| 分类 ios  | 标签 ARC  内存泄漏  Instruments  性能调优 

iOS内存管理深度解析:ARC、内存泄漏检测与性能优化实战指南

内存管理是iOS开发中的核心技术之一,直接影响应用的性能、稳定性和用户体验。本文将深入探讨iOS内存管理的各个方面,从ARC机制到内存泄漏检测,再到性能优化策略,为开发者提供全面的内存管理解决方案。

内存管理概述

内存管理架构

@interface MemoryManagementArchitecture : NSObject

@property (nonatomic, strong) NSMutableDictionary *memoryMetrics;
@property (nonatomic, strong) NSMutableArray *allocationHistory;
@property (nonatomic, assign) NSUInteger currentMemoryUsage;
@property (nonatomic, assign) NSUInteger peakMemoryUsage;

+ (instancetype)sharedArchitecture;

// 内存监控
- (void)startMemoryMonitoring;
- (void)stopMemoryMonitoring;
- (void)recordMemoryAllocation:(NSUInteger)size forObject:(NSString *)objectType;
- (void)recordMemoryDeallocation:(NSUInteger)size forObject:(NSString *)objectType;

// 内存分析
- (NSDictionary *)getCurrentMemoryReport;
- (NSArray *)getMemoryAllocationHistory;
- (void)analyzeMemoryUsagePatterns;

// 内存优化
- (void)performMemoryCleanup;
- (void)optimizeMemoryUsage;
- (NSArray *)getMemoryOptimizationSuggestions;

// 内存警告处理
- (void)handleMemoryWarning;
- (void)registerForMemoryWarnings;

@end

@implementation MemoryManagementArchitecture

+ (instancetype)sharedArchitecture {
    static MemoryManagementArchitecture *sharedInstance = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        sharedInstance = [[self alloc] init];
    });
    return sharedInstance;
}

- (instancetype)init {
    self = [super init];
    if (self) {
        self.memoryMetrics = [NSMutableDictionary dictionary];
        self.allocationHistory = [NSMutableArray array];
        self.currentMemoryUsage = 0;
        self.peakMemoryUsage = 0;
        
        [self registerForMemoryWarnings];
    }
    return self;
}

- (void)startMemoryMonitoring {
    // 启动内存监控
    NSTimer *monitoringTimer = [NSTimer scheduledTimerWithTimeInterval:1.0
                                                                target:self
                                                              selector:@selector(updateMemoryMetrics)
                                                              userInfo:nil
                                                               repeats:YES];
    
    NSLog(@"内存监控已启动");
}

- (void)updateMemoryMetrics {
    // 获取当前内存使用情况
    struct mach_task_basic_info info;
    mach_msg_type_number_t size = MACH_TASK_BASIC_INFO_COUNT;
    kern_return_t kerr = task_info(mach_task_self(), MACH_TASK_BASIC_INFO, (task_info_t)&info, &size);
    
    if (kerr == KERN_SUCCESS) {
        NSUInteger memoryUsage = info.resident_size;
        self.currentMemoryUsage = memoryUsage;
        
        if (memoryUsage > self.peakMemoryUsage) {
            self.peakMemoryUsage = memoryUsage;
        }
        
        // 记录内存使用历史
        NSDictionary *memorySnapshot = @{
            @"timestamp": @([[NSDate date] timeIntervalSince1970]),
            @"memoryUsage": @(memoryUsage),
            @"memoryUsageMB": @(memoryUsage / (1024.0 * 1024.0))
        };
        
        [self.allocationHistory addObject:memorySnapshot];
        
        // 保持历史记录在合理范围内
        if (self.allocationHistory.count > 1000) {
            [self.allocationHistory removeObjectAtIndex:0];
        }
    }
}

- (void)recordMemoryAllocation:(NSUInteger)size forObject:(NSString *)objectType {
    NSString *key = [NSString stringWithFormat:@"allocation_%@", objectType];
    NSNumber *currentCount = self.memoryMetrics[key] ?: @0;
    self.memoryMetrics[key] = @([currentCount integerValue] + 1);
    
    NSString *sizeKey = [NSString stringWithFormat:@"size_%@", objectType];
    NSNumber *currentSize = self.memoryMetrics[sizeKey] ?: @0;
    self.memoryMetrics[sizeKey] = @([currentSize unsignedIntegerValue] + size);
    
    NSLog(@"记录内存分配: %@ - %lu bytes", objectType, (unsigned long)size);
}

- (void)recordMemoryDeallocation:(NSUInteger)size forObject:(NSString *)objectType {
    NSString *key = [NSString stringWithFormat:@"deallocation_%@", objectType];
    NSNumber *currentCount = self.memoryMetrics[key] ?: @0;
    self.memoryMetrics[key] = @([currentCount integerValue] + 1);
    
    NSString *sizeKey = [NSString stringWithFormat:@"size_%@", objectType];
    NSNumber *currentSize = self.memoryMetrics[sizeKey] ?: @0;
    NSUInteger newSize = [currentSize unsignedIntegerValue] > size ? [currentSize unsignedIntegerValue] - size : 0;
    self.memoryMetrics[sizeKey] = @(newSize);
    
    NSLog(@"记录内存释放: %@ - %lu bytes", objectType, (unsigned long)size);
}

- (NSDictionary *)getCurrentMemoryReport {
    NSMutableDictionary *report = [NSMutableDictionary dictionary];
    
    report[@"currentMemoryUsage"] = @(self.currentMemoryUsage);
    report[@"currentMemoryUsageMB"] = @(self.currentMemoryUsage / (1024.0 * 1024.0));
    report[@"peakMemoryUsage"] = @(self.peakMemoryUsage);
    report[@"peakMemoryUsageMB"] = @(self.peakMemoryUsage / (1024.0 * 1024.0));
    report[@"memoryMetrics"] = [self.memoryMetrics copy];
    report[@"timestamp"] = @([[NSDate date] timeIntervalSince1970]);
    
    return report;
}

- (NSArray *)getMemoryAllocationHistory {
    return [self.allocationHistory copy];
}

- (void)analyzeMemoryUsagePatterns {
    NSLog(@"=== 内存使用模式分析 ===");
    
    if (self.allocationHistory.count < 2) {
        NSLog(@"数据不足,无法进行分析");
        return;
    }
    
    // 计算内存使用趋势
    NSDictionary *firstSnapshot = self.allocationHistory.firstObject;
    NSDictionary *lastSnapshot = self.allocationHistory.lastObject;
    
    CGFloat firstUsage = [firstSnapshot[@"memoryUsageMB"] doubleValue];
    CGFloat lastUsage = [lastSnapshot[@"memoryUsageMB"] doubleValue];
    CGFloat trend = lastUsage - firstUsage;
    
    NSLog(@"内存使用趋势: %.2f MB (%@)", trend, trend > 0 ? @"增长" : @"下降");
    
    // 分析内存峰值
    CGFloat peakUsageMB = self.peakMemoryUsage / (1024.0 * 1024.0);
    NSLog(@"峰值内存使用: %.2f MB", peakUsageMB);
    
    // 分析对象分配情况
    for (NSString *key in self.memoryMetrics) {
        if ([key hasPrefix:@"allocation_"]) {
            NSString *objectType = [key substringFromIndex:11];
            NSInteger allocations = [self.memoryMetrics[key] integerValue];
            NSString *deallocKey = [NSString stringWithFormat:@"deallocation_%@", objectType];
            NSInteger deallocations = [self.memoryMetrics[deallocKey] integerValue];
            NSInteger leaks = allocations - deallocations;
            
            if (leaks > 0) {
                NSLog(@"潜在内存泄漏: %@ - %ld个对象未释放", objectType, (long)leaks);
            }
        }
    }
}

- (void)performMemoryCleanup {
    NSLog(@"执行内存清理...");
    
    // 清理缓存
    [[NSURLCache sharedURLCache] removeAllCachedResponses];
    
    // 清理图片缓存(如果使用了图片缓存库)
    // [[SDImageCache sharedImageCache] clearMemory];
    
    // 触发垃圾回收
    [[NSNotificationCenter defaultCenter] postNotificationName:UIApplicationDidReceiveMemoryWarningNotification object:nil];
    
    NSLog(@"内存清理完成");
}

- (void)optimizeMemoryUsage {
    NSLog(@"优化内存使用...");
    
    // 分析当前内存使用情况
    [self analyzeMemoryUsagePatterns];
    
    // 执行内存清理
    [self performMemoryCleanup];
    
    // 提供优化建议
    NSArray *suggestions = [self getMemoryOptimizationSuggestions];
    for (NSString *suggestion in suggestions) {
        NSLog(@"优化建议: %@", suggestion);
    }
}

- (NSArray *)getMemoryOptimizationSuggestions {
    NSMutableArray *suggestions = [NSMutableArray array];
    
    CGFloat currentUsageMB = self.currentMemoryUsage / (1024.0 * 1024.0);
    
    if (currentUsageMB > 100.0) {
        [suggestions addObject:@"内存使用过高,建议检查是否存在内存泄漏"];
    }
    
    if (currentUsageMB > 200.0) {
        [suggestions addObject:@"内存使用严重超标,建议立即进行内存优化"];
    }
    
    // 检查对象分配不平衡
    for (NSString *key in self.memoryMetrics) {
        if ([key hasPrefix:@"allocation_"]) {
            NSString *objectType = [key substringFromIndex:11];
            NSInteger allocations = [self.memoryMetrics[key] integerValue];
            NSString *deallocKey = [NSString stringWithFormat:@"deallocation_%@", objectType];
            NSInteger deallocations = [self.memoryMetrics[deallocKey] integerValue];
            
            if (allocations > deallocations + 10) {
                [suggestions addObject:[NSString stringWithFormat:@"检查%@对象的内存管理,可能存在泄漏", objectType]];
            }
        }
    }
    
    if (suggestions.count == 0) {
        [suggestions addObject:@"内存使用正常,继续保持良好的内存管理习惯"];
    }
    
    return suggestions;
}

- (void)handleMemoryWarning {
    NSLog(@"收到内存警告,执行紧急内存清理");
    
    // 执行紧急内存清理
    [self performMemoryCleanup];
    
    // 记录内存警告事件
    NSDictionary *warningEvent = @{
        @"type": @"memoryWarning",
        @"timestamp": @([[NSDate date] timeIntervalSince1970]),
        @"memoryUsage": @(self.currentMemoryUsage)
    };
    
    [self.allocationHistory addObject:warningEvent];
}

- (void)registerForMemoryWarnings {
    [[NSNotificationCenter defaultCenter] addObserver:self
                                             selector:@selector(handleMemoryWarning)
                                                 name:UIApplicationDidReceiveMemoryWarningNotification
                                               object:nil];
}

- (void)dealloc {
    [[NSNotificationCenter defaultCenter] removeObserver:self];
}

@end

内存管理最佳实践

内存管理最佳实践指南

@interface MemoryManagementBestPractices : NSObject

+ (void)demonstrateARCBestPractices;
+ (void)showCommonMemoryLeakPatterns;
+ (void)demonstrateProperObjectLifecycleManagement;
+ (void)showPerformanceOptimizationTechniques;
+ (void)demonstrateMemoryDebuggingTechniques;

@end

@implementation MemoryManagementBestPractices

+ (void)demonstrateARCBestPractices {
    NSLog(@"=== ARC最佳实践 ===");
    
    NSLog(@"1. 正确使用strong、weak、unsafe_unretained修饰符:");
    NSLog(@"   - strong: 默认修饰符,保持对象存活");
    NSLog(@"   - weak: 不保持对象存活,对象释放时自动设为nil");
    NSLog(@"   - unsafe_unretained: 不保持对象存活,不自动设为nil(危险)");
    
    NSLog(@"\n2. 避免循环引用:");
    NSLog(@"   - delegate使用weak引用");
    NSLog(@"   - block中使用weakSelf模式");
    NSLog(@"   - 父子关系中子对象不强引用父对象");
    
    NSLog(@"\n3. 正确的block使用模式:");
    NSLog(@"   __weak typeof(self) weakSelf = self;");
    NSLog(@"   [someObject doSomethingWithBlock:^{");
    NSLog(@"       __strong typeof(weakSelf) strongSelf = weakSelf;");
    NSLog(@"       if (strongSelf) {");
    NSLog(@"           // 安全使用strongSelf");
    NSLog(@"       }");
    NSLog(@"   }];");
    
    NSLog(@"\n4. 集合对象的内存管理:");
    NSLog(@"   - 及时移除不需要的对象");
    NSLog(@"   - 使用弱引用集合避免循环引用");
    NSLog(@"   - 注意集合的生命周期");
}

+ (void)showCommonMemoryLeakPatterns {
    NSLog(@"=== 常见内存泄漏模式 ===");
    
    NSLog(@"1. 循环引用泄漏:");
    NSLog(@"   问题: A对象强引用B对象,B对象强引用A对象");
    NSLog(@"   解决: 使用weak引用打破循环");
    
    NSLog(@"\n2. Delegate泄漏:");
    NSLog(@"   问题: delegate使用strong引用");
    NSLog(@"   解决: delegate使用weak引用");
    
    NSLog(@"\n3. Block泄漏:");
    NSLog(@"   问题: block强引用self,self强引用block");
    NSLog(@"   解决: 使用weakSelf/strongSelf模式");
    
    NSLog(@"\n4. Timer泄漏:");
    NSLog(@"   问题: NSTimer强引用target,target强引用timer");
    NSLog(@"   解决: 使用弱引用target或及时invalidate");
    
    NSLog(@"\n5. Observer泄漏:");
    NSLog(@"   问题: 注册通知观察者后未移除");
    NSLog(@"   解决: 在dealloc中移除观察者");
    
    NSLog(@"\n6. 单例泄漏:");
    NSLog(@"   问题: 单例持有其他对象的强引用");
    NSLog(@"   解决: 使用弱引用或及时清理");
}

+ (void)demonstrateProperObjectLifecycleManagement {
    NSLog(@"=== 正确的对象生命周期管理 ===");
    
    NSLog(@"1. 对象创建阶段:");
    NSLog(@"   - 使用工厂方法或初始化方法");
    NSLog(@"   - 避免在init方法中进行复杂操作");
    NSLog(@"   - 确保对象完全初始化后再使用");
    
    NSLog(@"\n2. 对象使用阶段:");
    NSLog(@"   - 合理管理对象的引用关系");
    NSLog(@"   - 避免过度持有对象");
    NSLog(@"   - 及时释放不需要的引用");
    
    NSLog(@"\n3. 对象销毁阶段:");
    NSLog(@"   - 在dealloc中清理资源");
    NSLog(@"   - 移除通知观察者");
    NSLog(@"   - 停止定时器和异步操作");
    NSLog(@"   - 关闭文件和网络连接");
    
    // 示例:正确的dealloc实现
    NSLog(@"\n正确的dealloc实现示例:");
    NSLog(@"- (void)dealloc {");
    NSLog(@"    [[NSNotificationCenter defaultCenter] removeObserver:self];");
    NSLog(@"    [self.timer invalidate];");
    NSLog(@"    [self.networkOperation cancel];");
    NSLog(@"    // ARC会自动处理其他清理工作");
    NSLog(@"}");
}

+ (void)showPerformanceOptimizationTechniques {
    NSLog(@"=== 性能优化技巧 ===");
    
    NSLog(@"1. 懒加载(Lazy Loading):");
    NSLog(@"   - 延迟创建昂贵的对象");
    NSLog(@"   - 按需初始化视图和数据");
    NSLog(@"   - 使用懒加载属性");
    
    NSLog(@"\n2. 对象池(Object Pooling):");
    NSLog(@"   - 重用UITableViewCell和UICollectionViewCell");
    NSLog(@"   - 创建自定义对象池");
    NSLog(@"   - 重用昂贵的对象(如NSDateFormatter)");
    
    NSLog(@"\n3. 内存缓存优化:");
    NSLog(@"   - 合理设置缓存大小");
    NSLog(@"   - 实施LRU缓存策略");
    NSLog(@"   - 响应内存警告清理缓存");
    
    NSLog(@"\n4. 图片内存优化:");
    NSLog(@"   - 使用适当的图片格式和尺寸");
    NSLog(@"   - 实施图片压缩和缓存");
    NSLog(@"   - 延迟加载和释放图片");
    
    NSLog(@"\n5. 集合优化:");
    NSLog(@"   - 选择合适的集合类型");
    NSLog(@"   - 预分配集合容量");
    NSLog(@"   - 使用弱引用集合避免循环引用");
}

+ (void)demonstrateMemoryDebuggingTechniques {
    NSLog(@"=== 内存调试技巧 ===");
    
    NSLog(@"1. 使用Instruments工具:");
    NSLog(@"   - Allocations: 监控内存分配");
    NSLog(@"   - Leaks: 检测内存泄漏");
    NSLog(@"   - VM Tracker: 监控虚拟内存");
    NSLog(@"   - Activity Monitor: 监控整体性能");
    
    NSLog(@"\n2. 静态分析:");
    NSLog(@"   - 使用Xcode的静态分析器");
    NSLog(@"   - 检查潜在的内存问题");
    NSLog(@"   - 修复分析器报告的问题");
    
    NSLog(@"\n3. 运行时检测:");
    NSLog(@"   - 启用Address Sanitizer");
    NSLog(@"   - 使用Zombie Objects检测");
    NSLog(@"   - 监控内存使用模式");
    
    NSLog(@"\n4. 代码审查:");
    NSLog(@"   - 检查引用关系");
    NSLog(@"   - 验证dealloc实现");
    NSLog(@"   - 确认资源清理");
    
    NSLog(@"\n5. 单元测试:");
    NSLog(@"   - 编写内存泄漏测试");
    NSLog(@"   - 验证对象生命周期");
    NSLog(@"   - 测试内存压力场景");
}

@end

综合内存管理系统

统一内存管理器

@interface ComprehensiveMemoryManager : NSObject

@property (nonatomic, strong) MemoryManagementArchitecture *architecture;
@property (nonatomic, strong) ARCManager *arcManager;
@property (nonatomic, strong) MemoryLeakDetector *leakDetector;
@property (nonatomic, strong) MemoryPerformanceOptimizer *performanceOptimizer;
@property (nonatomic, strong) NSMutableDictionary *managementConfig;

+ (instancetype)sharedManager;

// 系统初始化
- (void)initializeMemoryManagement;
- (void)configureMemoryManagement:(NSDictionary *)config;

// 统一监控
- (void)startComprehensiveMonitoring;
- (void)stopComprehensiveMonitoring;
- (NSDictionary *)generateComprehensiveReport;

// 智能优化
- (void)performIntelligentOptimization;
- (void)adaptToDeviceCapabilities;
- (void)optimizeForCurrentUsage;

// 问题诊断
- (NSArray *)diagnoseMemoryIssues;
- (NSDictionary *)generateDiagnosticReport;
- (NSArray *)getOptimizationRecommendations;

@end

@implementation ComprehensiveMemoryManager

+ (instancetype)sharedManager {
    static ComprehensiveMemoryManager *sharedInstance = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        sharedInstance = [[self alloc] init];
    });
    return sharedInstance;
}

- (instancetype)init {
    self = [super init];
    if (self) {
        self.architecture = [MemoryManagementArchitecture sharedArchitecture];
        self.arcManager = [ARCManager sharedManager];
        self.leakDetector = [MemoryLeakDetector sharedDetector];
        self.performanceOptimizer = [MemoryPerformanceOptimizer sharedOptimizer];
        self.managementConfig = [NSMutableDictionary dictionary];
        
        [self initializeMemoryManagement];
    }
    return self;
}

- (void)initializeMemoryManagement {
    NSLog(@"初始化综合内存管理系统");
    
    // 设置默认配置
    [self configureMemoryManagement:@{
        @"enableMonitoring": @YES,
        @"enableLeakDetection": @YES,
        @"enablePerformanceOptimization": @YES,
        @"monitoringInterval": @5.0,
        @"optimizationThreshold": @0.8,
        @"memoryWarningThreshold": @0.9
    }];
    
    // 适配设备能力
    [self adaptToDeviceCapabilities];
    
    NSLog(@"综合内存管理系统初始化完成");
}

- (void)configureMemoryManagement:(NSDictionary *)config {
    [self.managementConfig addEntriesFromDictionary:config];
    
    NSLog(@"内存管理配置已更新:");
    for (NSString *key in config) {
        NSLog(@"  %@: %@", key, config[key]);
    }
}

- (void)adaptToDeviceCapabilities {
    NSLog(@"适配设备能力...");
    
    // 获取设备信息
    NSUInteger physicalMemory = [NSProcessInfo processInfo].physicalMemory;
    NSString *deviceModel = [[UIDevice currentDevice] model];
    
    NSLog(@"设备信息: %@, 物理内存: %.2f GB", deviceModel, physicalMemory / (1024.0 * 1024.0 * 1024.0));
    
    // 根据设备能力调整配置
    if (physicalMemory < 2ULL * 1024 * 1024 * 1024) { // 小于2GB
        [self configureMemoryManagement:@{
            @"monitoringInterval": @3.0,
            @"optimizationThreshold": @0.7,
            @"memoryWarningThreshold": @0.8,
            @"aggressiveOptimization": @YES
        }];
        NSLog(@"低内存设备配置已应用");
    } else if (physicalMemory >= 4ULL * 1024 * 1024 * 1024) { // 大于等于4GB
        [self configureMemoryManagement:@{
            @"monitoringInterval": @10.0,
            @"optimizationThreshold": @0.9,
            @"memoryWarningThreshold": @0.95,
            @"aggressiveOptimization": @NO
        }];
        NSLog(@"高内存设备配置已应用");
    }
}

- (void)startComprehensiveMonitoring {
    NSLog(@"启动综合内存监控");
    
    BOOL enableMonitoring = [self.managementConfig[@"enableMonitoring"] boolValue];
    BOOL enableLeakDetection = [self.managementConfig[@"enableLeakDetection"] boolValue];
    BOOL enablePerformanceOptimization = [self.managementConfig[@"enablePerformanceOptimization"] boolValue];
    
    if (enableMonitoring) {
        [self.architecture startMemoryMonitoring];
    }
    
    if (enableLeakDetection) {
        [self.leakDetector startLeakDetection];
    }
    
    if (enablePerformanceOptimization) {
        [self.performanceOptimizer startPerformanceMonitoring];
    }
    
    NSLog(@"综合内存监控已启动");
}

- (void)stopComprehensiveMonitoring {
    NSLog(@"停止综合内存监控");
    
    [self.architecture stopMemoryMonitoring];
    [self.leakDetector stopLeakDetection];
    [self.performanceOptimizer stopPerformanceMonitoring];
    
    NSLog(@"综合内存监控已停止");
}

- (NSDictionary *)generateComprehensiveReport {
    NSLog(@"生成综合内存报告...");
    
    NSMutableDictionary *report = [NSMutableDictionary dictionary];
    
    // 基础内存信息
    report[@"basicMemoryInfo"] = [self.architecture getCurrentMemoryReport];
    
    // 泄漏检测报告
    report[@"leakDetectionReport"] = [self.leakDetector generateLeakReport];
    
    // 性能优化历史
    report[@"optimizationHistory"] = self.performanceOptimizer.optimizationHistory;
    
    // 系统配置
    report[@"systemConfiguration"] = [self.managementConfig copy];
    
    // 诊断结果
    report[@"diagnosticResults"] = [self diagnoseMemoryIssues];
    
    // 优化建议
    report[@"optimizationRecommendations"] = [self getOptimizationRecommendations];
    
    // 报告元数据
    report[@"reportMetadata"] = @{
        @"timestamp": @([[NSDate date] timeIntervalSince1970]),
        @"reportVersion": @"1.0",
        @"deviceInfo": @{
            @"model": [[UIDevice currentDevice] model],
            @"systemVersion": [[UIDevice currentDevice] systemVersion],
            @"physicalMemory": @([NSProcessInfo processInfo].physicalMemory)
        }
    };
    
    NSLog(@"综合内存报告生成完成");
    return report;
}

- (void)performIntelligentOptimization {
    NSLog(@"执行智能内存优化...");
    
    // 分析当前内存状况
    NSDictionary *memoryReport = [self.architecture getCurrentMemoryReport];
    CGFloat currentUsageMB = [memoryReport[@"currentMemoryUsageMB"] doubleValue];
    
    // 获取优化阈值
    CGFloat optimizationThreshold = [self.managementConfig[@"optimizationThreshold"] doubleValue];
    NSUInteger physicalMemory = [NSProcessInfo processInfo].physicalMemory;
    CGFloat thresholdMB = (physicalMemory / (1024.0 * 1024.0)) * optimizationThreshold;
    
    if (currentUsageMB > thresholdMB) {
        NSLog(@"内存使用超过阈值(%.2fMB > %.2fMB),执行优化", currentUsageMB, thresholdMB);
        
        // 执行性能优化
        [self.performanceOptimizer optimizeMemoryUsage];
        
        // 检测并处理泄漏
        NSArray *leaks = [self.leakDetector detectMemoryLeaks];
        if (leaks.count > 0) {
            NSLog(@"检测到 %lu 个潜在泄漏,建议进一步调查", (unsigned long)leaks.count);
        }
    } else {
        NSLog(@"内存使用正常(%.2fMB <= %.2fMB),无需优化", currentUsageMB, thresholdMB);
    }
}

- (void)optimizeForCurrentUsage {
    NSLog(@"根据当前使用情况优化内存");
    
    // 获取当前应用状态
    UIApplicationState appState = [[UIApplication sharedApplication] applicationState];
    
    switch (appState) {
        case UIApplicationStateActive:
            NSLog(@"应用处于活跃状态,执行轻度优化");
            [self.performanceOptimizer performModerateMemoryCleanup];
            break;
            
        case UIApplicationStateInactive:
            NSLog(@"应用处于非活跃状态,执行中度优化");
            [self.performanceOptimizer optimizeMemoryUsage];
            break;
            
        case UIApplicationStateBackground:
            NSLog(@"应用处于后台状态,执行激进优化");
            [self.performanceOptimizer performAggressiveMemoryCleanup];
            break;
    }
}

- (NSArray *)diagnoseMemoryIssues {
    NSLog(@"诊断内存问题...");
    
    NSMutableArray *issues = [NSMutableArray array];
    
    // 检查内存泄漏
    NSArray *leaks = [self.leakDetector detectMemoryLeaks];
    if (leaks.count > 0) {
        [issues addObject:@{
            @"type": @"MemoryLeak",
            @"severity": @"High",
            @"count": @(leaks.count),
            @"description": [NSString stringWithFormat:@"检测到 %lu 个潜在内存泄漏", (unsigned long)leaks.count]
        }];
    }
    
    // 检查内存使用过高
    NSDictionary *memoryReport = [self.architecture getCurrentMemoryReport];
    CGFloat currentUsageMB = [memoryReport[@"currentMemoryUsageMB"] doubleValue];
    
    if (currentUsageMB > 200.0) {
        [issues addObject:@{
            @"type": @"HighMemoryUsage",
            @"severity": @"Medium",
            @"usage": @(currentUsageMB),
            @"description": [NSString stringWithFormat:@"内存使用过高: %.2fMB", currentUsageMB]
        }];
    }
    
    // 检查内存增长趋势
    NSArray *allocationHistory = [self.architecture getMemoryAllocationHistory];
    if (allocationHistory.count >= 2) {
        NSDictionary *first = allocationHistory.firstObject;
        NSDictionary *last = allocationHistory.lastObject;
        
        CGFloat firstUsage = [first[@"memoryUsageMB"] doubleValue];
        CGFloat lastUsage = [last[@"memoryUsageMB"] doubleValue];
        CGFloat growthRate = (lastUsage - firstUsage) / firstUsage;
        
        if (growthRate > 0.5) { // 增长超过50%
            [issues addObject:@{
                @"type": @"RapidMemoryGrowth",
                @"severity": @"Medium",
                @"growthRate": @(growthRate),
                @"description": [NSString stringWithFormat:@"内存快速增长: %.1f%%", growthRate * 100]
            }];
        }
    }
    
    NSLog(@"诊断完成,发现 %lu 个问题", (unsigned long)issues.count);
    return issues;
}

- (NSDictionary *)generateDiagnosticReport {
    NSArray *issues = [self diagnoseMemoryIssues];
    
    NSMutableDictionary *report = [NSMutableDictionary dictionary];
    report[@"timestamp"] = @([[NSDate date] timeIntervalSince1970]);
    report[@"totalIssues"] = @(issues.count);
    report[@"issues"] = issues;
    
    // 计算严重程度分布
    NSMutableDictionary *severityCount = [NSMutableDictionary dictionary];
    for (NSDictionary *issue in issues) {
        NSString *severity = issue[@"severity"];
        NSNumber *count = severityCount[severity] ?: @0;
        severityCount[severity] = @([count integerValue] + 1);
    }
    report[@"severityDistribution"] = severityCount;
    
    // 总体健康评分
    NSInteger totalScore = 100;
    for (NSDictionary *issue in issues) {
        NSString *severity = issue[@"severity"];
        if ([severity isEqualToString:@"High"]) {
            totalScore -= 20;
        } else if ([severity isEqualToString:@"Medium"]) {
            totalScore -= 10;
        } else {
            totalScore -= 5;
        }
    }
    report[@"healthScore"] = @(MAX(0, totalScore));
    
    return report;
}

- (NSArray *)getOptimizationRecommendations {
    NSMutableArray *recommendations = [NSMutableArray array];
    
    NSArray *issues = [self diagnoseMemoryIssues];
    
    for (NSDictionary *issue in issues) {
        NSString *type = issue[@"type"];
        
        if ([type isEqualToString:@"MemoryLeak"]) {
            [recommendations addObject:@"使用Instruments的Leaks工具进行详细分析"];
            [recommendations addObject:@"检查delegate、block和timer的引用关系"];
            [recommendations addObject:@"确保在dealloc中正确清理资源"];
        } else if ([type isEqualToString:@"HighMemoryUsage"]) {
            [recommendations addObject:@"实施懒加载减少内存占用"];
            [recommendations addObject:@"优化图片和缓存使用"];
            [recommendations addObject:@"考虑使用对象池重用昂贵对象"];
        } else if ([type isEqualToString:@"RapidMemoryGrowth"]) {
            [recommendations addObject:@"检查是否存在内存泄漏"];
            [recommendations addObject:@"优化数据结构和算法"];
            [recommendations addObject:@"实施更积极的内存清理策略"];
        }
    }
    
    if (recommendations.count == 0) {
        [recommendations addObject:@"内存管理状况良好,继续保持"];
        [recommendations addObject:@"定期进行内存分析和优化"];
    }
    
    return recommendations;
}

@end

内存管理开发总结

核心要点回顾

  1. ARC机制理解
    • 掌握strong、weak、unsafe_unretained的使用场景
    • 理解引用计数的工作原理
    • 避免循环引用的最佳实践
  2. 内存泄漏预防
    • 正确使用delegate模式
    • 掌握block的内存管理
    • 及时清理观察者和定时器
  3. 性能优化策略
    • 实施懒加载和对象池
    • 优化图片和缓存管理
    • 响应内存警告进行清理
  4. 调试和监控
    • 使用Instruments工具进行分析
    • 实施运行时内存监控
    • 建立自动化检测机制
  5. 最佳实践应用
    • 建立完整的内存管理体系
    • 根据设备能力调整策略
    • 持续监控和优化内存使用

通过本文的深入学习,开发者可以全面掌握iOS内存管理的各个方面,构建高效、稳定的iOS应用,为用户提供优质的使用体验。

内存泄漏检测与调试

内存泄漏检测器

@interface MemoryLeakDetector : NSObject

@property (nonatomic, strong) NSMutableDictionary *allocatedObjects;
@property (nonatomic, strong) NSMutableArray *leakReports;
@property (nonatomic, assign) BOOL isMonitoring;

+ (instancetype)sharedDetector;

// 泄漏检测
- (void)startLeakDetection;
- (void)stopLeakDetection;
- (void)registerObjectAllocation:(id)object withInfo:(NSDictionary *)info;
- (void)registerObjectDeallocation:(id)object;

// 泄漏分析
- (NSArray *)detectMemoryLeaks;
- (NSDictionary *)generateLeakReport;
- (void)analyzeLeakPatterns;

// Instruments集成
- (void)enableInstrumentsIntegration;
- (void)logForInstruments:(NSString *)message withObject:(id)object;

// 自动化检测
- (void)performAutomaticLeakScan;
- (void)schedulePeriodicLeakScans;

@end

@implementation MemoryLeakDetector

+ (instancetype)sharedDetector {
    static MemoryLeakDetector *sharedInstance = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        sharedInstance = [[self alloc] init];
    });
    return sharedInstance;
}

- (instancetype)init {
    self = [super init];
    if (self) {
        self.allocatedObjects = [NSMutableDictionary dictionary];
        self.leakReports = [NSMutableArray array];
        self.isMonitoring = NO;
    }
    return self;
}

- (void)startLeakDetection {
    if (self.isMonitoring) {
        NSLog(@"内存泄漏检测已在运行中");
        return;
    }
    
    self.isMonitoring = YES;
    NSLog(@"开始内存泄漏检测");
    
    // 启用Instruments集成
    [self enableInstrumentsIntegration];
    
    // 安排定期扫描
    [self schedulePeriodicLeakScans];
}

- (void)stopLeakDetection {
    if (!self.isMonitoring) {
        NSLog(@"内存泄漏检测未在运行");
        return;
    }
    
    self.isMonitoring = NO;
    NSLog(@"停止内存泄漏检测");
    
    // 执行最终扫描
    [self performAutomaticLeakScan];
}

- (void)registerObjectAllocation:(id)object withInfo:(NSDictionary *)info {
    if (!self.isMonitoring || !object) {
        return;
    }
    
    NSString *objectKey = [NSString stringWithFormat:@"%p", object];
    
    NSMutableDictionary *objectInfo = [NSMutableDictionary dictionaryWithDictionary:info];
    objectInfo[@"allocationTime"] = @([[NSDate date] timeIntervalSince1970]);
    objectInfo[@"className"] = NSStringFromClass([object class]);
    objectInfo[@"retainCount"] = @(CFGetRetainCount((__bridge CFTypeRef)object));
    
    // 获取调用栈信息
    NSArray *callStack = [NSThread callStackSymbols];
    objectInfo[@"allocationStack"] = callStack;
    
    self.allocatedObjects[objectKey] = objectInfo;
    
    [self logForInstruments:@"Object Allocated" withObject:object];
}

- (void)registerObjectDeallocation:(id)object {
    if (!self.isMonitoring || !object) {
        return;
    }
    
    NSString *objectKey = [NSString stringWithFormat:@"%p", object];
    [self.allocatedObjects removeObjectForKey:objectKey];
    
    [self logForInstruments:@"Object Deallocated" withObject:object];
}

- (NSArray *)detectMemoryLeaks {
    NSMutableArray *leaks = [NSMutableArray array];
    NSTimeInterval currentTime = [[NSDate date] timeIntervalSince1970];
    
    for (NSString *objectKey in self.allocatedObjects) {
        NSDictionary *objectInfo = self.allocatedObjects[objectKey];
        NSTimeInterval allocationTime = [objectInfo[@"allocationTime"] doubleValue];
        NSTimeInterval age = currentTime - allocationTime;
        
        // 如果对象存在时间超过阈值,可能是泄漏
        if (age > 300.0) { // 5分钟阈值
            NSMutableDictionary *leak = [NSMutableDictionary dictionaryWithDictionary:objectInfo];
            leak[@"objectKey"] = objectKey;
            leak[@"age"] = @(age);
            leak[@"suspicionLevel"] = [self calculateSuspicionLevel:objectInfo age:age];
            
            [leaks addObject:leak];
        }
    }
    
    // 按可疑程度排序
    [leaks sortUsingComparator:^NSComparisonResult(NSDictionary *obj1, NSDictionary *obj2) {
        NSNumber *level1 = obj1[@"suspicionLevel"];
        NSNumber *level2 = obj2[@"suspicionLevel"];
        return [level2 compare:level1]; // 降序排列
    }];
    
    return leaks;
}

- (NSNumber *)calculateSuspicionLevel:(NSDictionary *)objectInfo age:(NSTimeInterval)age {
    CGFloat suspicion = 0.0;
    
    // 基于年龄的可疑度
    suspicion += age / 60.0; // 每分钟增加1分
    
    // 基于类型的可疑度
    NSString *className = objectInfo[@"className"];
    if ([className containsString:@"Controller"]) {
        suspicion += 10.0; // 控制器泄漏更严重
    } else if ([className containsString:@"View"]) {
        suspicion += 5.0; // 视图泄漏中等严重
    }
    
    // 基于引用计数的可疑度
    NSInteger retainCount = [objectInfo[@"retainCount"] integerValue];
    if (retainCount > 1) {
        suspicion += retainCount * 2.0;
    }
    
    return @(suspicion);
}

- (NSDictionary *)generateLeakReport {
    NSArray *leaks = [self detectMemoryLeaks];
    
    NSMutableDictionary *report = [NSMutableDictionary dictionary];
    report[@"timestamp"] = @([[NSDate date] timeIntervalSince1970]);
    report[@"totalAllocatedObjects"] = @(self.allocatedObjects.count);
    report[@"suspectedLeaks"] = @(leaks.count);
    report[@"leakDetails"] = leaks;
    
    // 统计泄漏类型
    NSMutableDictionary *leaksByClass = [NSMutableDictionary dictionary];
    for (NSDictionary *leak in leaks) {
        NSString *className = leak[@"className"];
        NSNumber *count = leaksByClass[className] ?: @0;
        leaksByClass[className] = @([count integerValue] + 1);
    }
    report[@"leaksByClass"] = leaksByClass;
    
    // 计算内存泄漏严重程度
    CGFloat totalSuspicion = 0.0;
    for (NSDictionary *leak in leaks) {
        totalSuspicion += [leak[@"suspicionLevel"] doubleValue];
    }
    report[@"totalSuspicionScore"] = @(totalSuspicion);
    
    NSString *severity;
    if (totalSuspicion < 10.0) {
        severity = @"低";
    } else if (totalSuspicion < 50.0) {
        severity = @"中";
    } else {
        severity = @"高";
    }
    report[@"severity"] = severity;
    
    [self.leakReports addObject:report];
    
    return report;
}

- (void)analyzeLeakPatterns {
    NSLog(@"=== 内存泄漏模式分析 ===");
    
    if (self.leakReports.count < 2) {
        NSLog(@"数据不足,无法进行模式分析");
        return;
    }
    
    // 分析泄漏趋势
    NSDictionary *firstReport = self.leakReports.firstObject;
    NSDictionary *lastReport = self.leakReports.lastObject;
    
    NSInteger firstLeaks = [firstReport[@"suspectedLeaks"] integerValue];
    NSInteger lastLeaks = [lastReport[@"suspectedLeaks"] integerValue];
    
    NSLog(@"泄漏趋势: 从 %ld 个增长到 %ld 个", (long)firstLeaks, (long)lastLeaks);
    
    // 分析最常见的泄漏类型
    NSMutableDictionary *classFrequency = [NSMutableDictionary dictionary];
    for (NSDictionary *report in self.leakReports) {
        NSDictionary *leaksByClass = report[@"leaksByClass"];
        for (NSString *className in leaksByClass) {
            NSNumber *count = leaksByClass[className];
            NSNumber *totalCount = classFrequency[className] ?: @0;
            classFrequency[className] = @([totalCount integerValue] + [count integerValue]);
        }
    }
    
    // 找出最常泄漏的类
    NSArray *sortedClasses = [classFrequency keysSortedByValueUsingComparator:^NSComparisonResult(NSNumber *obj1, NSNumber *obj2) {
        return [obj2 compare:obj1];
    }];
    
    NSLog(@"最常泄漏的类:");
    for (NSInteger i = 0; i < MIN(5, sortedClasses.count); i++) {
        NSString *className = sortedClasses[i];
        NSInteger count = [classFrequency[className] integerValue];
        NSLog(@"%ld. %@ - %ld次", (long)(i + 1), className, (long)count);
    }
}

- (void)enableInstrumentsIntegration {
    // 启用与Instruments的集成
    NSLog(@"启用Instruments集成");
    
    // 设置自定义标记点
    // 这些标记点可以在Instruments中看到
    if (@available(iOS 12.0, *)) {
        // 使用os_signpost进行标记
        // 这需要导入os/signpost.h
        NSLog(@"Instruments集成已启用(iOS 12.0+)");
    } else {
        NSLog(@"Instruments集成已启用(兼容模式)");
    }
}

- (void)logForInstruments:(NSString *)message withObject:(id)object {
    // 为Instruments创建日志
    NSString *className = NSStringFromClass([object class]);
    NSString *objectAddress = [NSString stringWithFormat:@"%p", object];
    
    NSString *instrumentsLog = [NSString stringWithFormat:@"[MemoryTracker] %@ - %@<%@>", 
                               message, className, objectAddress];
    
    NSLog(@"%@", instrumentsLog);
    
    // 如果可用,使用os_log进行更好的Instruments集成
    if (@available(iOS 10.0, *)) {
        // os_log(OS_LOG_DEFAULT, "%{public}@", instrumentsLog);
    }
}

- (void)performAutomaticLeakScan {
    NSLog(@"执行自动内存泄漏扫描...");
    
    NSDictionary *report = [self generateLeakReport];
    
    NSInteger leakCount = [report[@"suspectedLeaks"] integerValue];
    NSString *severity = report[@"severity"];
    
    NSLog(@"扫描完成: 发现 %ld 个可疑泄漏,严重程度: %@", (long)leakCount, severity);
    
    if (leakCount > 0) {
        NSLog(@"建议使用Instruments进行详细分析");
        [self analyzeLeakPatterns];
    }
}

- (void)schedulePeriodicLeakScans {
    // 安排定期泄漏扫描
    NSTimer *scanTimer = [NSTimer scheduledTimerWithTimeInterval:60.0 // 每分钟扫描一次
                                                          target:self
                                                        selector:@selector(performAutomaticLeakScan)
                                                        userInfo:nil
                                                         repeats:YES];
    
    NSLog(@"已安排定期内存泄漏扫描(每60秒)");
}

@end

Instruments工具使用指南

@interface InstrumentsHelper : NSObject

+ (void)setupInstrumentsLogging;
+ (void)logMemoryAllocation:(id)object withSize:(NSUInteger)size;
+ (void)logMemoryDeallocation:(id)object;
+ (void)markSignificantEvent:(NSString *)eventName;
+ (void)beginPerformanceRegion:(NSString *)regionName;
+ (void)endPerformanceRegion:(NSString *)regionName;

@end

@implementation InstrumentsHelper

+ (void)setupInstrumentsLogging {
    NSLog(@"=== Instruments使用指南 ===");
    NSLog(@"1. 打开Xcode,选择Product -> Profile");
    NSLog(@"2. 选择Allocations或Leaks模板");
    NSLog(@"3. 运行应用并观察内存分配情况");
    NSLog(@"4. 使用Mark Generation功能标记内存快照");
    NSLog(@"5. 分析内存增长和泄漏模式");
}

+ (void)logMemoryAllocation:(id)object withSize:(NSUInteger)size {
    NSString *className = NSStringFromClass([object class]);
    NSLog(@"[Instruments] 分配: %@ - %lu bytes", className, (unsigned long)size);
    
    // 为Instruments添加自定义标记
    [self markSignificantEvent:[NSString stringWithFormat:@"Alloc_%@", className]];
}

+ (void)logMemoryDeallocation:(id)object {
    NSString *className = NSStringFromClass([object class]);
    NSLog(@"[Instruments] 释放: %@", className);
    
    [self markSignificantEvent:[NSString stringWithFormat:@"Dealloc_%@", className]];
}

+ (void)markSignificantEvent:(NSString *)eventName {
    // 在Instruments中创建可见的标记点
    NSLog(@"[MARK] %@", eventName);
    
    // 如果使用os_signpost(iOS 12.0+)
    if (@available(iOS 12.0, *)) {
        // 这里可以使用os_signpost_event_emit
        NSLog(@"Signpost标记: %@", eventName);
    }
}

+ (void)beginPerformanceRegion:(NSString *)regionName {
    NSLog(@"[PERF_BEGIN] %@", regionName);
}

+ (void)endPerformanceRegion:(NSString *)regionName {
    NSLog(@"[PERF_END] %@", regionName);
}

@end

内存性能优化策略

内存性能优化器

@interface MemoryPerformanceOptimizer : NSObject

@property (nonatomic, strong) NSMutableDictionary *performanceMetrics;
@property (nonatomic, strong) NSMutableArray *optimizationHistory;
@property (nonatomic, assign) NSUInteger memoryPressureLevel;

+ (instancetype)sharedOptimizer;

// 性能监控
- (void)startPerformanceMonitoring;
- (void)stopPerformanceMonitoring;
- (void)recordMemoryOperation:(NSString *)operation withMetrics:(NSDictionary *)metrics;

// 内存优化
- (void)optimizeMemoryUsage;
- (void)performLazyLoading;
- (void)implementObjectPooling;
- (void)optimizeImageMemory;
- (void)optimizeCollectionMemory;

// 缓存管理
- (void)setupIntelligentCaching;
- (void)clearUnusedCache;
- (void)optimizeCacheSize;

// 内存压力处理
- (void)handleMemoryPressure:(NSUInteger)level;
- (void)implementMemoryWarningResponse;

@end

@implementation MemoryPerformanceOptimizer

+ (instancetype)sharedOptimizer {
    static MemoryPerformanceOptimizer *sharedInstance = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        sharedInstance = [[self alloc] init];
    });
    return sharedInstance;
}

- (instancetype)init {
    self = [super init];
    if (self) {
        self.performanceMetrics = [NSMutableDictionary dictionary];
        self.optimizationHistory = [NSMutableArray array];
        self.memoryPressureLevel = 0;
        
        [self setupIntelligentCaching];
        [self implementMemoryWarningResponse];
    }
    return self;
}

- (void)startPerformanceMonitoring {
    NSLog(@"开始内存性能监控");
    
    // 启动性能监控定时器
    NSTimer *monitoringTimer = [NSTimer scheduledTimerWithTimeInterval:5.0
                                                                target:self
                                                              selector:@selector(collectPerformanceMetrics)
                                                              userInfo:nil
                                                               repeats:YES];
    
    // 监控内存压力
    [self startMemoryPressureMonitoring];
}

- (void)collectPerformanceMetrics {
    // 收集内存性能指标
    struct mach_task_basic_info info;
    mach_msg_type_number_t size = MACH_TASK_BASIC_INFO_COUNT;
    kern_return_t kerr = task_info(mach_task_self(), MACH_TASK_BASIC_INFO, (task_info_t)&info, &size);
    
    if (kerr == KERN_SUCCESS) {
        NSUInteger currentMemory = info.resident_size;
        NSUInteger virtualMemory = info.virtual_size;
        
        NSDictionary *metrics = @{
            @"timestamp": @([[NSDate date] timeIntervalSince1970]),
            @"physicalMemory": @(currentMemory),
            @"virtualMemory": @(virtualMemory),
            @"memoryPressure": @(self.memoryPressureLevel)
        };
        
        [self recordMemoryOperation:@"PerformanceSnapshot" withMetrics:metrics];
        
        // 分析性能趋势
        [self analyzePerformanceTrends];
    }
}

- (void)startMemoryPressureMonitoring {
    // 监控系统内存压力
    dispatch_source_t memorySource = dispatch_source_create(DISPATCH_SOURCE_TYPE_MEMORYPRESSURE, 0, DISPATCH_MEMORYPRESSURE_WARN | DISPATCH_MEMORYPRESSURE_CRITICAL, dispatch_get_main_queue());
    
    dispatch_source_set_event_handler(memorySource, ^{
        unsigned long pressureLevel = dispatch_source_get_data(memorySource);
        [self handleMemoryPressure:pressureLevel];
    });
    
    dispatch_resume(memorySource);
    NSLog(@"内存压力监控已启动");
}

- (void)recordMemoryOperation:(NSString *)operation withMetrics:(NSDictionary *)metrics {
    NSMutableArray *operationHistory = self.performanceMetrics[operation];
    if (!operationHistory) {
        operationHistory = [NSMutableArray array];
        self.performanceMetrics[operation] = operationHistory;
    }
    
    [operationHistory addObject:metrics];
    
    // 保持历史记录在合理范围内
    if (operationHistory.count > 100) {
        [operationHistory removeObjectAtIndex:0];
    }
}

- (void)analyzePerformanceTrends {
    NSArray *snapshots = self.performanceMetrics[@"PerformanceSnapshot"];
    if (snapshots.count < 2) {
        return;
    }
    
    NSDictionary *latest = snapshots.lastObject;
    NSDictionary *previous = snapshots[snapshots.count - 2];
    
    NSUInteger latestMemory = [latest[@"physicalMemory"] unsignedIntegerValue];
    NSUInteger previousMemory = [previous[@"physicalMemory"] unsignedIntegerValue];
    
    CGFloat memoryGrowthRate = (CGFloat)(latestMemory - previousMemory) / previousMemory;
    
    if (memoryGrowthRate > 0.1) { // 内存增长超过10%
        NSLog(@"检测到快速内存增长: %.2f%%", memoryGrowthRate * 100);
        [self optimizeMemoryUsage];
    }
}

- (void)optimizeMemoryUsage {
    NSLog(@"执行内存优化...");
    
    // 执行各种优化策略
    [self performLazyLoading];
    [self implementObjectPooling];
    [self optimizeImageMemory];
    [self optimizeCollectionMemory];
    [self clearUnusedCache];
    
    // 记录优化操作
    NSDictionary *optimizationRecord = @{
        @"timestamp": @([[NSDate date] timeIntervalSince1970]),
        @"type": @"MemoryOptimization",
        @"strategies": @[@"LazyLoading", @"ObjectPooling", @"ImageOptimization", @"CollectionOptimization", @"CacheClearing"]
    };
    
    [self.optimizationHistory addObject:optimizationRecord];
    
    NSLog(@"内存优化完成");
}

- (void)performLazyLoading {
    NSLog(@"实施懒加载优化");
    
    // 懒加载示例:延迟初始化大对象
    // 这里提供概念性代码
    NSLog(@"优化策略:");
    NSLog(@"1. 延迟初始化视图控制器");
    NSLog(@"2. 按需加载图片资源");
    NSLog(@"3. 延迟创建数据模型");
    NSLog(@"4. 使用懒加载属性");
    
    // 示例:懒加载属性
    /*
    @property (nonatomic, strong) NSMutableArray *lazyArray;
    
    - (NSMutableArray *)lazyArray {
        if (!_lazyArray) {
            _lazyArray = [[NSMutableArray alloc] init];
        }
        return _lazyArray;
    }
    */
}

- (void)implementObjectPooling {
    NSLog(@"实施对象池优化");
    
    // 对象池可以减少频繁的对象创建和销毁
    NSLog(@"对象池优化策略:");
    NSLog(@"1. 重用UITableViewCell和UICollectionViewCell");
    NSLog(@"2. 创建自定义对象池");
    NSLog(@"3. 重用昂贵的对象(如NSDateFormatter)");
    
    // 示例:NSDateFormatter重用
    static NSDateFormatter *sharedFormatter = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        sharedFormatter = [[NSDateFormatter alloc] init];
        sharedFormatter.dateFormat = @"yyyy-MM-dd HH:mm:ss";
    });
    
    NSLog(@"共享DateFormatter已创建");
}

- (void)optimizeImageMemory {
    NSLog(@"优化图片内存使用");
    
    NSLog(@"图片优化策略:");
    NSLog(@"1. 使用适当的图片格式和尺寸");
    NSLog(@"2. 实施图片缓存和清理机制");
    NSLog(@"3. 使用图片压缩");
    NSLog(@"4. 延迟加载和释放图片");
    
    // 清理图片缓存
    [[NSURLCache sharedURLCache] removeAllCachedResponses];
    
    // 如果使用了第三方图片库
    // [[SDImageCache sharedImageCache] clearMemory];
    
    NSLog(@"图片缓存已清理");
}

- (void)optimizeCollectionMemory {
    NSLog(@"优化集合内存使用");
    
    NSLog(@"集合优化策略:");
    NSLog(@"1. 使用合适的集合类型");
    NSLog(@"2. 及时移除不需要的元素");
    NSLog(@"3. 使用弱引用集合(NSHashTable, NSMapTable)");
    NSLog(@"4. 避免在集合中存储大对象");
    
    // 示例:使用弱引用集合
    NSHashTable *weakSet = [NSHashTable weakObjectsHashTable];
    NSMapTable *weakMap = [NSMapTable strongToWeakObjectsMapTable];
    
    NSLog(@"弱引用集合已创建");
}

- (void)setupIntelligentCaching {
    NSLog(@"设置智能缓存系统");
    
    // 配置NSURLCache
    NSUInteger memoryCapacity = 10 * 1024 * 1024; // 10MB
    NSUInteger diskCapacity = 50 * 1024 * 1024;   // 50MB
    
    NSURLCache *cache = [[NSURLCache alloc] initWithMemoryCapacity:memoryCapacity
                                                      diskCapacity:diskCapacity
                                                          diskPath:nil];
    [NSURLCache setSharedURLCache:cache];
    
    NSLog(@"智能缓存系统已配置: 内存%luMB, 磁盘%luMB", 
          (unsigned long)(memoryCapacity / (1024 * 1024)), 
          (unsigned long)(diskCapacity / (1024 * 1024)));
}

- (void)clearUnusedCache {
    NSLog(@"清理未使用的缓存");
    
    // 清理URL缓存
    NSURLCache *cache = [NSURLCache sharedURLCache];
    NSUInteger beforeMemory = cache.currentMemoryUsage;
    NSUInteger beforeDisk = cache.currentDiskUsage;
    
    [cache removeAllCachedResponses];
    
    NSLog(@"缓存清理完成: 内存从%luKB降至%luKB, 磁盘从%luKB降至%luKB",
          (unsigned long)(beforeMemory / 1024), (unsigned long)(cache.currentMemoryUsage / 1024),
          (unsigned long)(beforeDisk / 1024), (unsigned long)(cache.currentDiskUsage / 1024));
}

- (void)optimizeCacheSize {
    NSLog(@"优化缓存大小");
    
    NSURLCache *cache = [NSURLCache sharedURLCache];
    
    // 根据可用内存动态调整缓存大小
    NSUInteger availableMemory = [NSProcessInfo processInfo].physicalMemory;
    NSUInteger optimalMemoryCache = availableMemory / 100; // 使用1%的物理内存
    NSUInteger optimalDiskCache = optimalMemoryCache * 5;  // 磁盘缓存是内存缓存的5倍
    
    // 限制最大缓存大小
    optimalMemoryCache = MIN(optimalMemoryCache, 50 * 1024 * 1024); // 最大50MB
    optimalDiskCache = MIN(optimalDiskCache, 200 * 1024 * 1024);    // 最大200MB
    
    NSURLCache *optimizedCache = [[NSURLCache alloc] initWithMemoryCapacity:optimalMemoryCache
                                                               diskCapacity:optimalDiskCache
                                                                   diskPath:nil];
    [NSURLCache setSharedURLCache:optimizedCache];
    
    NSLog(@"缓存大小已优化: 内存%luMB, 磁盘%luMB",
          (unsigned long)(optimalMemoryCache / (1024 * 1024)),
          (unsigned long)(optimalDiskCache / (1024 * 1024)));
}

- (void)handleMemoryPressure:(NSUInteger)level {
    self.memoryPressureLevel = level;
    
    NSString *pressureDescription;
    if (level & DISPATCH_MEMORYPRESSURE_CRITICAL) {
        pressureDescription = @"严重";
        // 执行激进的内存清理
        [self performAggressiveMemoryCleanup];
    } else if (level & DISPATCH_MEMORYPRESSURE_WARN) {
        pressureDescription = @"警告";
        // 执行温和的内存清理
        [self performModerateMemoryCleanup];
    } else {
        pressureDescription = @"正常";
    }
    
    NSLog(@"内存压力级别: %@", pressureDescription);
    
    // 记录内存压力事件
    NSDictionary *pressureEvent = @{
        @"timestamp": @([[NSDate date] timeIntervalSince1970]),
        @"level": @(level),
        @"description": pressureDescription
    };
    
    [self recordMemoryOperation:@"MemoryPressure" withMetrics:pressureEvent];
}

- (void)performAggressiveMemoryCleanup {
    NSLog(@"执行激进内存清理");
    
    // 清理所有可能的缓存
    [self clearUnusedCache];
    
    // 清理图片缓存
    [self optimizeImageMemory];
    
    // 触发垃圾回收
    [[NSNotificationCenter defaultCenter] postNotificationName:UIApplicationDidReceiveMemoryWarningNotification object:nil];
    
    // 清理临时文件
    [self clearTemporaryFiles];
    
    NSLog(@"激进内存清理完成");
}

- (void)performModerateMemoryCleanup {
    NSLog(@"执行温和内存清理");
    
    // 清理部分缓存
    NSURLCache *cache = [NSURLCache sharedURLCache];
    NSUInteger targetMemoryUsage = cache.memoryCapacity / 2;
    
    if (cache.currentMemoryUsage > targetMemoryUsage) {
        [cache removeAllCachedResponses];
    }
    
    NSLog(@"温和内存清理完成");
}

- (void)clearTemporaryFiles {
    NSString *tempDir = NSTemporaryDirectory();
    NSFileManager *fileManager = [NSFileManager defaultManager];
    NSArray *tempFiles = [fileManager contentsOfDirectoryAtPath:tempDir error:nil];
    
    NSUInteger clearedFiles = 0;
    for (NSString *fileName in tempFiles) {
        NSString *filePath = [tempDir stringByAppendingPathComponent:fileName];
        if ([fileManager removeItemAtPath:filePath error:nil]) {
            clearedFiles++;
        }
    }
    
    NSLog(@"清理了 %lu 个临时文件", (unsigned long)clearedFiles);
}

- (void)implementMemoryWarningResponse {
    // 注册内存警告通知
    [[NSNotificationCenter defaultCenter] addObserver:self
                                             selector:@selector(handleMemoryWarning:)
                                                 name:UIApplicationDidReceiveMemoryWarningNotification
                                               object:nil];
    
    NSLog(@"内存警告响应已实施");
}

- (void)handleMemoryWarning:(NSNotification *)notification {
    NSLog(@"收到系统内存警告");
    
    // 执行紧急内存清理
    [self performAggressiveMemoryCleanup];
    
    // 记录内存警告事件
    NSDictionary *warningEvent = @{
        @"timestamp": @([[NSDate date] timeIntervalSince1970]),
        @"type": @"SystemMemoryWarning"
    };
    
    [self recordMemoryOperation:@"MemoryWarning" withMetrics:warningEvent];
}

- (void)dealloc {
    [[NSNotificationCenter defaultCenter] removeObserver:self];
}

@end

ARC(自动引用计数)深度解析

ARC工作原理

ARC(Automatic Reference Counting)是iOS的自动内存管理机制,通过在编译时自动插入retain和release调用来管理对象的生命周期。

@interface ARCManager : NSObject

@property (nonatomic, strong) NSMutableDictionary *referenceCountMap;
@property (nonatomic, strong) NSMutableArray *retainCycleDetector;

+ (instancetype)sharedManager;

// ARC分析
- (void)analyzeObjectRetainCount:(id)object;
- (void)detectRetainCycles;
- (void)logReferenceCountForObject:(id)object withDescription:(NSString *)description;

// 引用类型管理
- (void)demonstrateStrongReferences;
- (void)demonstrateWeakReferences;
- (void)demonstrateUnownedReferences;

// 内存管理最佳实践
- (void)showProperDelegatePattern;
- (void)showProperBlockUsage;
- (void)showProperCollectionHandling;

@end

@implementation ARCManager

+ (instancetype)sharedManager {
    static ARCManager *sharedInstance = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        sharedInstance = [[self alloc] init];
    });
    return sharedInstance;
}

- (instancetype)init {
    self = [super init];
    if (self) {
        self.referenceCountMap = [NSMutableDictionary dictionary];
        self.retainCycleDetector = [NSMutableArray array];
    }
    return self;
}

- (void)analyzeObjectRetainCount:(id)object {
    if (!object) {
        NSLog(@"对象为nil,无法分析引用计数");
        return;
    }
    
    // 注意:在ARC环境下,直接获取引用计数并不总是准确的
    // 这里仅用于演示目的
    CFIndex retainCount = CFGetRetainCount((__bridge CFTypeRef)object);
    
    NSString *objectDescription = [NSString stringWithFormat:@"%@<%p>", NSStringFromClass([object class]), object];
    NSLog(@"对象 %@ 的引用计数: %ld", objectDescription, (long)retainCount);
    
    // 记录引用计数历史
    NSString *key = [NSString stringWithFormat:@"%p", object];
    NSMutableArray *history = self.referenceCountMap[key];
    if (!history) {
        history = [NSMutableArray array];
        self.referenceCountMap[key] = history;
    }
    
    NSDictionary *record = @{
        @"timestamp": @([[NSDate date] timeIntervalSince1970]),
        @"retainCount": @(retainCount),
        @"description": objectDescription
    };
    
    [history addObject:record];
}

- (void)detectRetainCycles {
    NSLog(@"=== 循环引用检测 ===");
    
    // 这是一个简化的循环引用检测示例
    // 实际的循环引用检测需要更复杂的算法
    
    for (NSString *objectKey in self.referenceCountMap) {
        NSArray *history = self.referenceCountMap[objectKey];
        
        if (history.count >= 2) {
            NSDictionary *firstRecord = history.firstObject;
            NSDictionary *lastRecord = history.lastObject;
            
            NSInteger firstCount = [firstRecord[@"retainCount"] integerValue];
            NSInteger lastCount = [lastRecord[@"retainCount"] integerValue];
            
            if (lastCount > firstCount && lastCount > 1) {
                NSLog(@"潜在循环引用: %@ (引用计数从 %ld 增长到 %ld)", 
                      lastRecord[@"description"], (long)firstCount, (long)lastCount);
            }
        }
    }
}

- (void)logReferenceCountForObject:(id)object withDescription:(NSString *)description {
    [self analyzeObjectRetainCount:object];
    NSLog(@"引用计数检查点: %@", description);
}

- (void)demonstrateStrongReferences {
    NSLog(@"=== Strong引用示例 ===");
    
    // Strong引用会增加对象的引用计数
    NSMutableArray *strongArray = [[NSMutableArray alloc] init];
    [self logReferenceCountForObject:strongArray withDescription:@"创建strong数组"];
    
    NSMutableArray *anotherStrongRef = strongArray;
    [self logReferenceCountForObject:strongArray withDescription:@"添加另一个strong引用"];
    
    anotherStrongRef = nil;
    [self logReferenceCountForObject:strongArray withDescription:@"移除一个strong引用"];
    
    strongArray = nil;
    NSLog(@"所有strong引用已移除,对象应该被释放");
}

- (void)demonstrateWeakReferences {
    NSLog(@"=== Weak引用示例 ===");
    
    NSMutableArray *strongArray = [[NSMutableArray alloc] init];
    __weak NSMutableArray *weakArray = strongArray;
    
    [self logReferenceCountForObject:strongArray withDescription:@"创建strong引用和weak引用"];
    
    NSLog(@"Weak引用指向的对象: %@", weakArray ? @"存在" : @"nil");
    
    strongArray = nil;
    NSLog(@"Strong引用移除后,weak引用指向的对象: %@", weakArray ? @"存在" : @"nil");
}

- (void)demonstrateUnownedReferences {
    NSLog(@"=== Unowned引用示例 ===");
    
    // Unowned引用类似于weak,但不会自动设置为nil
    // 主要用于Swift,在Objective-C中较少使用
    // 这里提供概念性说明
    
    NSLog(@"Unowned引用不会增加引用计数,但不会自动设置为nil");
    NSLog(@"使用unowned时必须确保引用的对象在使用期间一直存在");
    NSLog(@"否则会导致悬空指针和崩溃");
}

- (void)showProperDelegatePattern {
    NSLog(@"=== 正确的Delegate模式 ===");
    
    // 正确的delegate模式应该使用weak引用避免循环引用
    NSLog(@"// 正确的delegate声明");
    NSLog(@"@property (nonatomic, weak) id<SomeDelegate> delegate;");
    NSLog(@"");
    NSLog(@"// 错误的delegate声明(会导致循环引用)");
    NSLog(@"@property (nonatomic, strong) id<SomeDelegate> delegate; // 错误!");
}

- (void)showProperBlockUsage {
    NSLog(@"=== 正确的Block使用模式 ===");
    
    // 演示如何避免block中的循环引用
    __weak typeof(self) weakSelf = self;
    
    void (^properBlock)(void) = ^{
        __strong typeof(weakSelf) strongSelf = weakSelf;
        if (strongSelf) {
            // 安全地使用strongSelf
            NSLog(@"在block中安全地使用self: %@", strongSelf);
        }
    };
    
    properBlock();
    
    NSLog(@"Block使用最佳实践:");
    NSLog(@"1. 使用__weak typeof(self) weakSelf = self;");
    NSLog(@"2. 在block内部使用__strong typeof(weakSelf) strongSelf = weakSelf;");
    NSLog(@"3. 检查strongSelf是否为nil");
}

- (void)showProperCollectionHandling {
    NSLog(@"=== 正确的集合处理模式 ===");
    
    // 演示如何正确处理包含对象的集合
    NSMutableArray *objectArray = [NSMutableArray array];
    
    // 添加对象到集合
    NSObject *testObject = [[NSObject alloc] init];
    [objectArray addObject:testObject];
    [self logReferenceCountForObject:testObject withDescription:@"对象添加到数组后"];
    
    // 从集合中移除对象
    [objectArray removeObject:testObject];
    [self logReferenceCountForObject:testObject withDescription:@"对象从数组移除后"];
    
    // 清空集合
    [objectArray removeAllObjects];
    NSLog(@"数组已清空,所有对象引用已移除");
    
    NSLog(@"集合处理最佳实践:");
    NSLog(@"1. 及时从集合中移除不需要的对象");
    NSLog(@"2. 使用removeAllObjects清空集合");
    NSLog(@"3. 注意集合中对象的生命周期");
}

@end

上一篇     下一篇