@interface MultithreadingArchitecture : NSObject

@property (nonatomic, strong) NSMutableDictionary *threadPools;
@property (nonatomic, strong) NSMutableDictionary *queueManagers;
@property (nonatomic, strong) NSMutableArray *performanceMetrics;
@property (nonatomic, strong) NSMutableDictionary *threadSafetyConfig;

+ (instancetype)sharedArchitecture;

// 架构初始化
- (void)initializeMultithreadingArchitecture;
- (void)configureThreadingEnvironment:(NSDictionary *)config;

// 线程池管理
- (void)createThreadPool:(NSString *)poolName withConfig:(NSDictionary *)config;
- (void)destroyThreadPool:(NSString *)poolName;
- (NSDictionary *)getThreadPoolStatus:(NSString *)poolName;

// 性能监控
- (void)startPerformanceMonitoring;
- (void)stopPerformanceMonitoring;
- (NSDictionary *)generatePerformanceReport;

// 线程安全检查
- (BOOL)validateThreadSafety:(NSObject *)object;
- (NSArray *)detectPotentialRaceConditions;

@end

@implementation MultithreadingArchitecture

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

- (instancetype)init {
    self = [super init];
    if (self) {
        self.threadPools = [NSMutableDictionary dictionary];
        self.queueManagers = [NSMutableDictionary dictionary];
        self.performanceMetrics = [NSMutableArray array];
        self.threadSafetyConfig = [NSMutableDictionary dictionary];
        
        [self initializeMultithreadingArchitecture];
    }
    return self;
}

- (void)initializeMultithreadingArchitecture {
    NSLog(@"初始化多线程架构...");
    
    // 配置默认线程环境
    [self configureThreadingEnvironment:@{
        @"maxConcurrentOperations": @4,
        @"queuePriority": @"default",
        @"enableDeadlockDetection": @YES,
        @"performanceMonitoringInterval": @1.0
    }];
    
    // 创建默认线程池
    [self createThreadPool:@"default" withConfig:@{
        @"maxThreads": @4,
        @"queueType": @"concurrent",
        @"priority": @"default"
    }];
    
    [self createThreadPool:@"background" withConfig:@{
        @"maxThreads": @2,
        @"queueType": @"concurrent",
        @"priority": @"background"
    }];
    
    [self createThreadPool:@"utility" withConfig:@{
        @"maxThreads": @2,
        @"queueType": @"concurrent",
        @"priority": @"utility"
    }];
    
    NSLog(@"多线程架构初始化完成");
}

- (void)configureThreadingEnvironment:(NSDictionary *)config {
    [self.threadSafetyConfig addEntriesFromDictionary:config];
    
    NSLog(@"线程环境配置已更新:");
    for (NSString *key in config) {
        NSLog(@"  %@: %@", key, config[key]);
    }
}

- (void)createThreadPool:(NSString *)poolName withConfig:(NSDictionary *)config {
    NSLog(@"创建线程池: %@", poolName);
    
    NSMutableDictionary *poolInfo = [NSMutableDictionary dictionary];
    poolInfo[@"config"] = config;
    poolInfo[@"createdAt"] = @([[NSDate date] timeIntervalSince1970]);
    poolInfo[@"status"] = @"active";
    poolInfo[@"taskCount"] = @0;
    poolInfo[@"completedTasks"] = @0;
    
    // 根据配置创建相应的队列
    NSString *queueType = config[@"queueType"];
    NSString *priority = config[@"priority"];
    
    dispatch_queue_attr_t attr = DISPATCH_QUEUE_SERIAL;
    if ([queueType isEqualToString:@"concurrent"]) {
        attr = DISPATCH_QUEUE_CONCURRENT;
    }
    
    dispatch_qos_class_t qos = DISPATCH_QOS_CLASS_DEFAULT;
    if ([priority isEqualToString:@"background"]) {
        qos = DISPATCH_QOS_CLASS_BACKGROUND;
    } else if ([priority isEqualToString:@"utility"]) {
        qos = DISPATCH_QOS_CLASS_UTILITY;
    } else if ([priority isEqualToString:@"userInitiated"]) {
        qos = DISPATCH_QOS_CLASS_USER_INITIATED;
    } else if ([priority isEqualToString:@"userInteractive"]) {
        qos = DISPATCH_QOS_CLASS_USER_INTERACTIVE;
    }
    
    dispatch_queue_attr_t qosAttr = dispatch_queue_attr_make_with_qos_class(attr, qos, 0);
    dispatch_queue_t queue = dispatch_queue_create([poolName UTF8String], qosAttr);
    
    poolInfo[@"queue"] = queue;
    
    self.threadPools[poolName] = poolInfo;
    
    NSLog(@"线程池 %@ 创建成功，类型: %@，优先级: %@", poolName, queueType, priority);
}

- (void)destroyThreadPool:(NSString *)poolName {
    if (self.threadPools[poolName]) {
        NSLog(@"销毁线程池: %@", poolName);
        [self.threadPools removeObjectForKey:poolName];
        NSLog(@"线程池 %@ 已销毁", poolName);
    } else {
        NSLog(@"线程池 %@ 不存在", poolName);
    }
}

- (NSDictionary *)getThreadPoolStatus:(NSString *)poolName {
    NSMutableDictionary *poolInfo = self.threadPools[poolName];
    if (poolInfo) {
        NSMutableDictionary *status = [NSMutableDictionary dictionary];
        status[@"name"] = poolName;
        status[@"status"] = poolInfo[@"status"];
        status[@"taskCount"] = poolInfo[@"taskCount"];
        status[@"completedTasks"] = poolInfo[@"completedTasks"];
        status[@"createdAt"] = poolInfo[@"createdAt"];
        status[@"config"] = poolInfo[@"config"];
        
        return status;
    }
    return nil;
}

- (void)startPerformanceMonitoring {
    NSLog(@"启动性能监控");
    
    NSTimeInterval interval = [self.threadSafetyConfig[@"performanceMonitoringInterval"] doubleValue];
    
    dispatch_queue_t monitorQueue = dispatch_queue_create("performance.monitor", DISPATCH_QUEUE_SERIAL);
    dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, monitorQueue);
    
    dispatch_source_set_timer(timer, dispatch_time(DISPATCH_TIME_NOW, 0), interval * NSEC_PER_SEC, 0.1 * NSEC_PER_SEC);
    
    dispatch_source_set_event_handler(timer, ^{
        [self collectPerformanceMetrics];
    });
    
    dispatch_resume(timer);
    
    // 存储timer引用以便后续停止
    self.threadSafetyConfig[@"performanceTimer"] = timer;
}

- (void)stopPerformanceMonitoring {
    NSLog(@"停止性能监控");
    
    dispatch_source_t timer = self.threadSafetyConfig[@"performanceTimer"];
    if (timer) {
        dispatch_source_cancel(timer);
        [self.threadSafetyConfig removeObjectForKey:@"performanceTimer"];
    }
}

- (void)collectPerformanceMetrics {
    NSMutableDictionary *metrics = [NSMutableDictionary dictionary];
    metrics[@"timestamp"] = @([[NSDate date] timeIntervalSince1970]);
    
    // 收集系统线程信息
    thread_array_t threadList;
    mach_msg_type_number_t threadCount;
    
    if (task_threads(mach_task_self(), &threadList, &threadCount) == KERN_SUCCESS) {
        metrics[@"systemThreadCount"] = @(threadCount);
        
        // 清理线程列表
        for (mach_msg_type_number_t i = 0; i < threadCount; i++) {
            mach_port_deallocate(mach_task_self(), threadList[i]);
        }
        vm_deallocate(mach_task_self(), (vm_address_t)threadList, threadCount * sizeof(thread_t));
    }
    
    // 收集线程池状态
    NSMutableDictionary *poolStatuses = [NSMutableDictionary dictionary];
    for (NSString *poolName in self.threadPools) {
        poolStatuses[poolName] = [self getThreadPoolStatus:poolName];
    }
    metrics[@"threadPoolStatuses"] = poolStatuses;
    
    // 收集CPU使用率
    metrics[@"cpuUsage"] = @([self getCurrentCPUUsage]);
    
    [self.performanceMetrics addObject:metrics];
    
    // 保持最近100条记录
    if (self.performanceMetrics.count > 100) {
        [self.performanceMetrics removeObjectAtIndex:0];
    }
}

- (double)getCurrentCPUUsage {
    kern_return_t kr;
    task_info_data_t tinfo;
    mach_msg_type_number_t task_info_count;
    
    task_info_count = TASK_INFO_MAX;
    kr = task_info(mach_task_self(), TASK_BASIC_INFO, (task_info_t)tinfo, &task_info_count);
    if (kr != KERN_SUCCESS) {
        return 0.0;
    }
    
    task_basic_info_t basic_info;
    thread_array_t thread_list;
    mach_msg_type_number_t thread_count;
    
    thread_info_data_t thinfo;
    mach_msg_type_number_t thread_info_count;
    
    thread_basic_info_t basic_info_th;
    uint32_t stat_thread = 0;
    
    basic_info = (task_basic_info_t)tinfo;
    
    kr = task_threads(mach_task_self(), &thread_list, &thread_count);
    if (kr != KERN_SUCCESS) {
        return 0.0;
    }
    
    if (thread_count > 0)
        stat_thread += thread_count;
    
    long tot_sec = 0;
    long tot_usec = 0;
    float tot_cpu = 0;
    int j;
    
    for (j = 0; j < thread_count; j++) {
        thread_info_count = THREAD_INFO_MAX;
        kr = thread_info(thread_list[j], THREAD_BASIC_INFO,
                        (thread_info_t)thinfo, &thread_info_count);
        if (kr != KERN_SUCCESS) {
            continue;
        }
        
        basic_info_th = (thread_basic_info_t)thinfo;
        
        if (!(basic_info_th->flags & TH_FLAGS_IDLE)) {
            tot_sec = tot_sec + basic_info_th->user_time.seconds + basic_info_th->system_time.seconds;
            tot_usec = tot_usec + basic_info_th->user_time.microseconds + basic_info_th->system_time.microseconds;
            tot_cpu = tot_cpu + basic_info_th->cpu_usage / (float)TH_USAGE_SCALE * 100.0;
        }
    }
    
    kr = vm_deallocate(mach_task_self(), (vm_offset_t)thread_list, thread_count * sizeof(thread_t));
    assert(kr == KERN_SUCCESS);
    
    return tot_cpu;
}

- (NSDictionary *)generatePerformanceReport {
    NSMutableDictionary *report = [NSMutableDictionary dictionary];
    
    report[@"reportTimestamp"] = @([[NSDate date] timeIntervalSince1970]);
    report[@"metricsCount"] = @(self.performanceMetrics.count);
    
    if (self.performanceMetrics.count > 0) {
        // 计算平均值
        double avgCPU = 0.0;
        double avgThreadCount = 0.0;
        
        for (NSDictionary *metrics in self.performanceMetrics) {
            avgCPU += [metrics[@"cpuUsage"] doubleValue];
            avgThreadCount += [metrics[@"systemThreadCount"] doubleValue];
        }
        
        avgCPU /= self.performanceMetrics.count;
        avgThreadCount /= self.performanceMetrics.count;
        
        report[@"averageCPUUsage"] = @(avgCPU);
        report[@"averageThreadCount"] = @(avgThreadCount);
        
        // 最新指标
        NSDictionary *latestMetrics = self.performanceMetrics.lastObject;
        report[@"currentCPUUsage"] = latestMetrics[@"cpuUsage"];
        report[@"currentThreadCount"] = latestMetrics[@"systemThreadCount"];
        report[@"currentThreadPoolStatuses"] = latestMetrics[@"threadPoolStatuses"];
    }
    
    // 线程池统计
    NSMutableDictionary *poolSummary = [NSMutableDictionary dictionary];
    for (NSString *poolName in self.threadPools) {
        NSDictionary *status = [self getThreadPoolStatus:poolName];
        poolSummary[poolName] = status;
    }
    report[@"threadPoolSummary"] = poolSummary;
    
    return report;
}

- (BOOL)validateThreadSafety:(NSObject *)object {
    // 简化的线程安全检查
    // 实际实现需要更复杂的分析
    
    if ([object conformsToProtocol:@protocol(NSLocking)]) {
        return YES;
    }
    
    // 检查是否为不可变对象
    if ([object isKindOfClass:[NSString class]] ||
        [object isKindOfClass:[NSNumber class]] ||
        [object isKindOfClass:[NSDate class]]) {
        return YES;
    }
    
    // 检查是否为线程安全的集合类
    if ([object isKindOfClass:[NSArray class]] ||
        [object isKindOfClass:[NSDictionary class]] ||
        [object isKindOfClass:[NSSet class]]) {
        // 不可变集合是线程安全的
        NSString *className = NSStringFromClass([object class]);
        if (![className hasPrefix:@"NSMutable"]) {
            return YES;
        }
    }
    
    return NO;
}

- (NSArray *)detectPotentialRaceConditions {
    NSMutableArray *warnings = [NSMutableArray array];
    
    // 这里可以实现更复杂的竞态条件检测逻辑
    // 例如检查共享资源的访问模式
    
    [warnings addObject:@{
        @"type": @"SharedResourceAccess",
        @"description": @"检测到对共享资源的并发访问",
        @"severity": @"Medium",
        @"recommendation": @"使用锁或其他同步机制保护共享资源"
    }];
    
    return warnings;
}

@end

@interface NSOperationManager : NSObject

@property (nonatomic, strong) NSMutableDictionary *operationQueues;
@property (nonatomic, strong) NSMutableArray *operations;
@property (nonatomic, strong) NSMutableDictionary *dependencies;
@property (nonatomic, strong) NSMutableDictionary *priorities;

+ (instancetype)sharedManager;

// 队列管理
- (NSOperationQueue *)createOperationQueue:(NSString *)name withMaxConcurrentOperations:(NSInteger)maxOps;
- (void)destroyOperationQueue:(NSString *)name;
- (NSOperationQueue *)getOperationQueue:(NSString *)name;

// 操作管理
- (NSOperation *)createBlockOperation:(NSString *)name withBlock:(void(^)(void))block;
- (NSOperation *)createCustomOperation:(NSString *)name withTarget:(id)target selector:(SEL)selector;
- (void)addOperation:(NSOperation *)operation toQueue:(NSString *)queueName;

// 依赖关系管理
- (void)addDependency:(NSOperation *)dependency toOperation:(NSOperation *)operation;
- (void)removeDependency:(NSOperation *)dependency fromOperation:(NSOperation *)operation;
- (NSArray *)getDependenciesForOperation:(NSOperation *)operation;

// 优先级管理
- (void)setQueuePriority:(NSOperationQueuePriority)priority forOperation:(NSOperation *)operation;
- (void)setQualityOfService:(NSQualityOfService)qos forOperation:(NSOperation *)operation;

// 操作控制
- (void)pauseOperationQueue:(NSString *)queueName;
- (void)resumeOperationQueue:(NSString *)queueName;
- (void)cancelAllOperationsInQueue:(NSString *)queueName;
- (void)cancelOperation:(NSOperation *)operation;

// 监控和统计
- (NSDictionary *)getOperationStatistics;
- (NSArray *)getActiveOperations;
- (void)logOperationPerformance;

@end

@implementation NSOperationManager

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

- (instancetype)init {
    self = [super init];
    if (self) {
        self.operationQueues = [NSMutableDictionary dictionary];
        self.operations = [NSMutableArray array];
        self.dependencies = [NSMutableDictionary dictionary];
        self.priorities = [NSMutableDictionary dictionary];
    }
    return self;
}

- (NSOperationQueue *)createOperationQueue:(NSString *)name withMaxConcurrentOperations:(NSInteger)maxOps {
    NSLog(@"创建操作队列: %@，最大并发数: %ld", name, (long)maxOps);
    
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    queue.name = name;
    queue.maxConcurrentOperationCount = maxOps;
    
    self.operationQueues[name] = @{
        @"queue": queue,
        @"maxConcurrentOperations": @(maxOps),
        @"createdAt": @([[NSDate date] timeIntervalSince1970]),
        @"totalOperations": @0,
        @"completedOperations": @0
    };
    
    return queue;
}

- (void)destroyOperationQueue:(NSString *)name {
    NSMutableDictionary *queueInfo = self.operationQueues[name];
    if (queueInfo) {
        NSLog(@"销毁操作队列: %@", name);
        
        NSOperationQueue *queue = queueInfo[@"queue"];
        [queue cancelAllOperations];
        [queue waitUntilAllOperationsAreFinished];
        
        [self.operationQueues removeObjectForKey:name];
    }
}

- (NSOperationQueue *)getOperationQueue:(NSString *)name {
    NSMutableDictionary *queueInfo = self.operationQueues[name];
    return queueInfo ? queueInfo[@"queue"] : nil;
}

- (NSOperation *)createBlockOperation:(NSString *)name withBlock:(void(^)(void))block {
    NSLog(@"创建块操作: %@", name);
    
    NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:block];
    operation.name = name;
    
    [self.operations addObject:@{
        @"operation": operation,
        @"name": name,
        @"type": @"block",
        @"createdAt": @([[NSDate date] timeIntervalSince1970]),
        @"status": @"created"
    }];
    
    return operation;
}

- (NSOperation *)createCustomOperation:(NSString *)name withTarget:(id)target selector:(SEL)selector {
    NSLog(@"创建自定义操作: %@", name);
    
    NSInvocationOperation *operation = [[NSInvocationOperation alloc] initWithTarget:target selector:selector object:nil];
    operation.name = name;
    
    [self.operations addObject:@{
        @"operation": operation,
        @"name": name,
        @"type": @"invocation",
        @"createdAt": @([[NSDate date] timeIntervalSince1970]),
        @"status": @"created"
    }];
    
    return operation;
}

- (void)addOperation:(NSOperation *)operation toQueue:(NSString *)queueName {
    NSOperationQueue *queue = [self getOperationQueue:queueName];
    if (queue && operation) {
        NSLog(@"添加操作 %@ 到队列 %@", operation.name, queueName);
        
        // 更新操作状态
        for (NSMutableDictionary *opInfo in self.operations) {
            if (opInfo[@"operation"] == operation) {
                opInfo[@"status"] = @"queued";
                opInfo[@"queueName"] = queueName;
                break;
            }
        }
        
        // 更新队列统计
        NSMutableDictionary *queueInfo = self.operationQueues[queueName];
        NSInteger totalOps = [queueInfo[@"totalOperations"] integerValue] + 1;
        queueInfo[@"totalOperations"] = @(totalOps);
        
        [queue addOperation:operation];
    }
}

- (void)addDependency:(NSOperation *)dependency toOperation:(NSOperation *)operation {
    if (dependency && operation) {
        NSLog(@"添加依赖: %@ -> %@", dependency.name, operation.name);
        
        [operation addDependency:dependency];
        
        // 记录依赖关系
        NSString *operationKey = [NSString stringWithFormat:@"%p", operation];
        NSMutableArray *deps = self.dependencies[operationKey];
        if (!deps) {
            deps = [NSMutableArray array];
            self.dependencies[operationKey] = deps;
        }
        [deps addObject:dependency];
    }
}

- (void)removeDependency:(NSOperation *)dependency fromOperation:(NSOperation *)operation {
    if (dependency && operation) {
        NSLog(@"移除依赖: %@ -> %@", dependency.name, operation.name);
        
        [operation removeDependency:dependency];
        
        // 更新依赖记录
        NSString *operationKey = [NSString stringWithFormat:@"%p", operation];
        NSMutableArray *deps = self.dependencies[operationKey];
        [deps removeObject:dependency];
    }
}

- (NSArray *)getDependenciesForOperation:(NSOperation *)operation {
    if (operation) {
        return operation.dependencies;
    }
    return @[];
}

- (void)setQueuePriority:(NSOperationQueuePriority)priority forOperation:(NSOperation *)operation {
    if (operation) {
        NSLog(@"设置操作 %@ 的队列优先级: %ld", operation.name, (long)priority);
        operation.queuePriority = priority;
        
        // 记录优先级设置
        NSString *operationKey = [NSString stringWithFormat:@"%p", operation];
        self.priorities[operationKey] = @{
            @"queuePriority": @(priority),
            @"setAt": @([[NSDate date] timeIntervalSince1970])
        };
    }
}

- (void)setQualityOfService:(NSQualityOfService)qos forOperation:(NSOperation *)operation {
    if (operation) {
        NSLog(@"设置操作 %@ 的服务质量: %ld", operation.name, (long)qos);
        operation.qualityOfService = qos;
        
        // 更新优先级记录
        NSString *operationKey = [NSString stringWithFormat:@"%p", operation];
        NSMutableDictionary *priorityInfo = self.priorities[operationKey];
        if (!priorityInfo) {
            priorityInfo = [NSMutableDictionary dictionary];
            self.priorities[operationKey] = priorityInfo;
        }
        priorityInfo[@"qualityOfService"] = @(qos);
        priorityInfo[@"qosSetAt"] = @([[NSDate date] timeIntervalSince1970]);
    }
}

- (void)pauseOperationQueue:(NSString *)queueName {
    NSOperationQueue *queue = [self getOperationQueue:queueName];
    if (queue) {
        NSLog(@"暂停操作队列: %@", queueName);
        queue.suspended = YES;
    }
}

- (void)resumeOperationQueue:(NSString *)queueName {
    NSOperationQueue *queue = [self getOperationQueue:queueName];
    if (queue) {
        NSLog(@"恢复操作队列: %@", queueName);
        queue.suspended = NO;
    }
}

- (void)cancelAllOperationsInQueue:(NSString *)queueName {
    NSOperationQueue *queue = [self getOperationQueue:queueName];
    if (queue) {
        NSLog(@"取消队列 %@ 中的所有操作", queueName);
        [queue cancelAllOperations];
        
        // 更新操作状态
        for (NSMutableDictionary *opInfo in self.operations) {
            if ([opInfo[@"queueName"] isEqualToString:queueName]) {
                opInfo[@"status"] = @"cancelled";
            }
        }
    }
}

- (void)cancelOperation:(NSOperation *)operation {
    if (operation) {
        NSLog(@"取消操作: %@", operation.name);
        [operation cancel];
        
        // 更新操作状态
        for (NSMutableDictionary *opInfo in self.operations) {
            if (opInfo[@"operation"] == operation) {
                opInfo[@"status"] = @"cancelled";
                break;
            }
        }
    }
}

- (NSDictionary *)getOperationStatistics {
    NSMutableDictionary *statistics = [NSMutableDictionary dictionary];
    
    statistics[@"totalQueues"] = @(self.operationQueues.count);
    statistics[@"totalOperations"] = @(self.operations.count);
    
    // 统计操作状态
    NSMutableDictionary *statusCount = [NSMutableDictionary dictionary];
    for (NSDictionary *opInfo in self.operations) {
        NSString *status = opInfo[@"status"];
        NSNumber *count = statusCount[status] ?: @0;
        statusCount[status] = @([count integerValue] + 1);
    }
    statistics[@"operationStatusDistribution"] = statusCount;
    
    // 队列详情
    NSMutableArray *queueDetails = [NSMutableArray array];
    for (NSString *queueName in self.operationQueues) {
        NSDictionary *queueInfo = self.operationQueues[queueName];
        NSOperationQueue *queue = queueInfo[@"queue"];
        
        [queueDetails addObject:@{
            @"name": queueName,
            @"maxConcurrentOperations": queueInfo[@"maxConcurrentOperations"],
            @"currentOperationCount": @(queue.operationCount),
            @"suspended": @(queue.isSuspended),
            @"totalOperations": queueInfo[@"totalOperations"],
            @"completedOperations": queueInfo[@"completedOperations"]
        }];
    }
    statistics[@"queueDetails"] = queueDetails;
    
    return statistics;
}

- (NSArray *)getActiveOperations {
    NSMutableArray *activeOps = [NSMutableArray array];
    
    for (NSDictionary *opInfo in self.operations) {
        NSOperation *operation = opInfo[@"operation"];
        if (operation.isExecuting || operation.isReady) {
            [activeOps addObject:@{
                @"name": operation.name ?: @"Unknown",
                @"isExecuting": @(operation.isExecuting),
                @"isReady": @(operation.isReady),
                @"isCancelled": @(operation.isCancelled),
                @"isFinished": @(operation.isFinished),
                @"queuePriority": @(operation.queuePriority),
                @"qualityOfService": @(operation.qualityOfService)
            }];
        }
    }
    
    return activeOps;
}

- (void)logOperationPerformance {
    NSDictionary *stats = [self getOperationStatistics];
    
    NSLog(@"=== NSOperation性能统计 ===");
    NSLog(@"总队列数: %@", stats[@"totalQueues"]);
    NSLog(@"总操作数: %@", stats[@"totalOperations"]);
    
    NSDictionary *statusDist = stats[@"operationStatusDistribution"];
    NSLog(@"操作状态分布:");
    for (NSString *status in statusDist) {
        NSLog(@"  %@: %@", status, statusDist[status]);
    }
    
    NSArray *queueDetails = stats[@"queueDetails"];
    NSLog(@"队列详情:");
    for (NSDictionary *queue in queueDetails) {
        NSLog(@"  %@: 当前操作数=%@, 最大并发=%@, 暂停=%@", 
              queue[@"name"], queue[@"currentOperationCount"], 
              queue[@"maxConcurrentOperations"], queue[@"suspended"]);
    }
}

@end

@interface CustomAsyncOperation : NSOperation

@property (nonatomic, copy) void(^executionBlock)(CustomAsyncOperation *operation);
@property (nonatomic, strong) NSMutableDictionary *userInfo;
@property (nonatomic, assign) NSTimeInterval timeout;
@property (nonatomic, strong) NSTimer *timeoutTimer;

- (instancetype)initWithExecutionBlock:(void(^)(CustomAsyncOperation *operation))block;
- (void)completeOperation;
- (void)failWithError:(NSError *)error;

@end

@implementation CustomAsyncOperation {
    BOOL _executing;
    BOOL _finished;
}

- (instancetype)initWithExecutionBlock:(void(^)(CustomAsyncOperation *operation))block {
    self = [super init];
    if (self) {
        self.executionBlock = block;
        self.userInfo = [NSMutableDictionary dictionary];
        self.timeout = 30.0; // 默认30秒超时
        _executing = NO;
        _finished = NO;
    }
    return self;
}

- (BOOL)isAsynchronous {
    return YES;
}

- (BOOL)isExecuting {
    return _executing;
}

- (BOOL)isFinished {
    return _finished;
}

- (void)start {
    if (self.isCancelled) {
        [self willChangeValueForKey:@"isFinished"];
        _finished = YES;
        [self didChangeValueForKey:@"isFinished"];
        return;
    }
    
    [self willChangeValueForKey:@"isExecuting"];
    _executing = YES;
    [self didChangeValueForKey:@"isExecuting"];
    
    NSLog(@"开始执行自定义异步操作: %@", self.name);
    
    // 设置超时定时器
    if (self.timeout > 0) {
        self.timeoutTimer = [NSTimer scheduledTimerWithTimeInterval:self.timeout
                                                             target:self
                                                           selector:@selector(handleTimeout)
                                                           userInfo:nil
                                                            repeats:NO];
    }
    
    // 执行操作
    if (self.executionBlock) {
        self.executionBlock(self);
    } else {
        [self completeOperation];
    }
}

- (void)completeOperation {
    NSLog(@"完成自定义异步操作: %@", self.name);
    
    [self.timeoutTimer invalidate];
    self.timeoutTimer = nil;
    
    [self willChangeValueForKey:@"isExecuting"];
    [self willChangeValueForKey:@"isFinished"];
    
    _executing = NO;
    _finished = YES;
    
    [self didChangeValueForKey:@"isExecuting"];
    [self didChangeValueForKey:@"isFinished"];
}

- (void)failWithError:(NSError *)error {
    NSLog(@"自定义异步操作失败: %@, 错误: %@", self.name, error.localizedDescription);
    
    self.userInfo[@"error"] = error;
    [self completeOperation];
}

- (void)handleTimeout {
    NSLog(@"自定义异步操作超时: %@", self.name);
    
    NSError *timeoutError = [NSError errorWithDomain:@"CustomOperationDomain"
                                                 code:1001
                                             userInfo:@{NSLocalizedDescriptionKey: @"操作超时"}];
    [self failWithError:timeoutError];
}

- (void)cancel {
    [super cancel];
    
    if (_executing) {
        NSLog(@"取消正在执行的自定义异步操作: %@", self.name);
        [self completeOperation];
    }
}

@end

@interface ThreadSafetyManager : NSObject

@property (nonatomic, strong) NSMutableDictionary *locks;
@property (nonatomic, strong) NSMutableDictionary *conditions;
@property (nonatomic, strong) NSMutableDictionary *barriers;
@property (nonatomic, strong) NSMutableDictionary *atomicCounters;

+ (instancetype)sharedManager;

// 锁管理
- (NSLock *)createLock:(NSString *)name;
- (NSRecursiveLock *)createRecursiveLock:(NSString *)name;
- (NSConditionLock *)createConditionLock:(NSString *)name withCondition:(NSInteger)condition;
- (void)destroyLock:(NSString *)name;

// 读写锁
- (pthread_rwlock_t *)createReadWriteLock:(NSString *)name;
- (void)readLock:(NSString *)name block:(void(^)(void))block;
- (void)writeLock:(NSString *)name block:(void(^)(void))block;

// 条件变量
- (NSCondition *)createCondition:(NSString *)name;
- (void)waitForCondition:(NSString *)name;
- (void)signalCondition:(NSString *)name;
- (void)broadcastCondition:(NSString *)name;

// 原子操作
- (void)createAtomicCounter:(NSString *)name withInitialValue:(int64_t)value;
- (int64_t)incrementAtomicCounter:(NSString *)name;
- (int64_t)decrementAtomicCounter:(NSString *)name;
- (int64_t)getAtomicCounterValue:(NSString *)name;

// 线程安全集合
- (NSMutableArray *)createThreadSafeArray:(NSString *)name;
- (NSMutableDictionary *)createThreadSafeDictionary:(NSString *)name;
- (NSMutableSet *)createThreadSafeSet:(NSString *)name;

// 死锁检测
- (BOOL)detectDeadlock;
- (NSArray *)getDeadlockReport;

@end

@implementation ThreadSafetyManager

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

- (instancetype)init {
    self = [super init];
    if (self) {
        self.locks = [NSMutableDictionary dictionary];
        self.conditions = [NSMutableDictionary dictionary];
        self.barriers = [NSMutableDictionary dictionary];
        self.atomicCounters = [NSMutableDictionary dictionary];
    }
    return self;
}

- (NSLock *)createLock:(NSString *)name {
    NSLog(@"创建锁: %@", name);
    
    NSLock *lock = [[NSLock alloc] init];
    lock.name = name;
    
    self.locks[name] = @{
        @"lock": lock,
        @"type": @"NSLock",
        @"createdAt": @([[NSDate date] timeIntervalSince1970]),
        @"lockCount": @0
    };
    
    return lock;
}

- (NSRecursiveLock *)createRecursiveLock:(NSString *)name {
    NSLog(@"创建递归锁: %@", name);
    
    NSRecursiveLock *lock = [[NSRecursiveLock alloc] init];
    lock.name = name;
    
    self.locks[name] = @{
        @"lock": lock,
        @"type": @"NSRecursiveLock",
        @"createdAt": @([[NSDate date] timeIntervalSince1970]),
        @"lockCount": @0
    };
    
    return lock;
}

- (NSConditionLock *)createConditionLock:(NSString *)name withCondition:(NSInteger)condition {
    NSLog(@"创建条件锁: %@，条件: %ld", name, (long)condition);
    
    NSConditionLock *lock = [[NSConditionLock alloc] initWithCondition:condition];
    lock.name = name;
    
    self.locks[name] = @{
        @"lock": lock,
        @"type": @"NSConditionLock",
        @"condition": @(condition),
        @"createdAt": @([[NSDate date] timeIntervalSince1970]),
        @"lockCount": @0
    };
    
    return lock;
}

- (void)destroyLock:(NSString *)name {
    if (self.locks[name]) {
        NSLog(@"销毁锁: %@", name);
        [self.locks removeObjectForKey:name];
    }
}

- (pthread_rwlock_t *)createReadWriteLock:(NSString *)name {
    NSLog(@"创建读写锁: %@", name);
    
    pthread_rwlock_t *rwlock = malloc(sizeof(pthread_rwlock_t));
    pthread_rwlock_init(rwlock, NULL);
    
    self.locks[name] = @{
        @"lock": [NSValue valueWithPointer:rwlock],
        @"type": @"pthread_rwlock_t",
        @"createdAt": @([[NSDate date] timeIntervalSince1970]),
        @"readCount": @0,
        @"writeCount": @0
    };
    
    return rwlock;
}

- (void)readLock:(NSString *)name block:(void(^)(void))block {
    NSMutableDictionary *lockInfo = self.locks[name];
    if (lockInfo && [lockInfo[@"type"] isEqualToString:@"pthread_rwlock_t"]) {
        pthread_rwlock_t *rwlock = [lockInfo[@"lock"] pointerValue];
        
        pthread_rwlock_rdlock(rwlock);
        
        NSInteger readCount = [lockInfo[@"readCount"] integerValue] + 1;
        lockInfo[@"readCount"] = @(readCount);
        
        NSLog(@"获取读锁: %@，读计数: %ld", name, (long)readCount);
        
        if (block) {
            block();
        }
        
        pthread_rwlock_unlock(rwlock);
        NSLog(@"释放读锁: %@", name);
    }
}

- (void)writeLock:(NSString *)name block:(void(^)(void))block {
    NSMutableDictionary *lockInfo = self.locks[name];
    if (lockInfo && [lockInfo[@"type"] isEqualToString:@"pthread_rwlock_t"]) {
        pthread_rwlock_t *rwlock = [lockInfo[@"lock"] pointerValue];
        
        pthread_rwlock_wrlock(rwlock);
        
        NSInteger writeCount = [lockInfo[@"writeCount"] integerValue] + 1;
        lockInfo[@"writeCount"] = @(writeCount);
        
        NSLog(@"获取写锁: %@，写计数: %ld", name, (long)writeCount);
        
        if (block) {
            block();
        }
        
        pthread_rwlock_unlock(rwlock);
        NSLog(@"释放写锁: %@", name);
    }
}

- (NSCondition *)createCondition:(NSString *)name {
    NSLog(@"创建条件变量: %@", name);
    
    NSCondition *condition = [[NSCondition alloc] init];
    condition.name = name;
    
    self.conditions[name] = @{
        @"condition": condition,
        @"createdAt": @([[NSDate date] timeIntervalSince1970]),
        @"waitCount": @0,
        @"signalCount": @0
    };
    
    return condition;
}

- (void)waitForCondition:(NSString *)name {
    NSMutableDictionary *conditionInfo = self.conditions[name];
    if (conditionInfo) {
        NSCondition *condition = conditionInfo[@"condition"];
        
        [condition lock];
        
        NSInteger waitCount = [conditionInfo[@"waitCount"] integerValue] + 1;
        conditionInfo[@"waitCount"] = @(waitCount);
        
        NSLog(@"等待条件: %@，等待计数: %ld", name, (long)waitCount);
        [condition wait];
        NSLog(@"条件满足: %@", name);
        
        [condition unlock];
    }
}

- (void)signalCondition:(NSString *)name {
    NSMutableDictionary *conditionInfo = self.conditions[name];
    if (conditionInfo) {
        NSCondition *condition = conditionInfo[@"condition"];
        
        [condition lock];
        
        NSInteger signalCount = [conditionInfo[@"signalCount"] integerValue] + 1;
        conditionInfo[@"signalCount"] = @(signalCount);
        
        NSLog(@"发送信号: %@，信号计数: %ld", name, (long)signalCount);
        [condition signal];
        
        [condition unlock];
    }
}

- (void)broadcastCondition:(NSString *)name {
    NSMutableDictionary *conditionInfo = self.conditions[name];
    if (conditionInfo) {
        NSCondition *condition = conditionInfo[@"condition"];
        
        [condition lock];
        
        NSLog(@"广播条件: %@", name);
        [condition broadcast];
        
        [condition unlock];
    }
}

- (void)createAtomicCounter:(NSString *)name withInitialValue:(int64_t)value {
    NSLog(@"创建原子计数器: %@，初始值: %lld", name, value);
    
    int64_t *counter = malloc(sizeof(int64_t));
    *counter = value;
    
    self.atomicCounters[name] = @{
        @"counter": [NSValue valueWithPointer:counter],
        @"initialValue": @(value),
        @"createdAt": @([[NSDate date] timeIntervalSince1970])
    };
}

- (int64_t)incrementAtomicCounter:(NSString *)name {
    NSDictionary *counterInfo = self.atomicCounters[name];
    if (counterInfo) {
        int64_t *counter = [counterInfo[@"counter"] pointerValue];
        int64_t newValue = OSAtomicIncrement64(counter);
        NSLog(@"原子递增计数器 %@: %lld", name, newValue);
        return newValue;
    }
    return 0;
}

- (int64_t)decrementAtomicCounter:(NSString *)name {
    NSDictionary *counterInfo = self.atomicCounters[name];
    if (counterInfo) {
        int64_t *counter = [counterInfo[@"counter"] pointerValue];
        int64_t newValue = OSAtomicDecrement64(counter);
        NSLog(@"原子递减计数器 %@: %lld", name, newValue);
        return newValue;
    }
    return 0;
}

- (int64_t)getAtomicCounterValue:(NSString *)name {
    NSDictionary *counterInfo = self.atomicCounters[name];
    if (counterInfo) {
        int64_t *counter = [counterInfo[@"counter"] pointerValue];
        return *counter;
    }
    return 0;
}

- (NSMutableArray *)createThreadSafeArray:(NSString *)name {
    NSLog(@"创建线程安全数组: %@", name);
    
    // 使用串行队列保证线程安全
    dispatch_queue_t queue = dispatch_queue_create([[NSString stringWithFormat:@"array.%@", name] UTF8String], DISPATCH_QUEUE_SERIAL);
    
    // 创建包装类来提供线程安全的数组操作
    // 这里简化实现，实际应用中需要完整的线程安全包装
    NSMutableArray *array = [NSMutableArray array];
    
    return array;
}

- (NSMutableDictionary *)createThreadSafeDictionary:(NSString *)name {
    NSLog(@"创建线程安全字典: %@", name);
    
    // 类似数组的实现
    NSMutableDictionary *dictionary = [NSMutableDictionary dictionary];
    
    return dictionary;
}

- (NSMutableSet *)createThreadSafeSet:(NSString *)name {
    NSLog(@"创建线程安全集合: %@", name);
    
    NSMutableSet *set = [NSMutableSet set];
    
    return set;
}

- (BOOL)detectDeadlock {
    // 简化的死锁检测实现
    // 实际实现需要更复杂的算法来检测循环等待
    
    NSLog(@"执行死锁检测...");
    
    // 检查是否有锁被长时间持有
    NSTimeInterval currentTime = [[NSDate date] timeIntervalSince1970];
    
    for (NSString *lockName in self.locks) {
        NSDictionary *lockInfo = self.locks[lockName];
        NSTimeInterval createdAt = [lockInfo[@"createdAt"] doubleValue];
        
        if (currentTime - createdAt > 30.0) { // 30秒阈值
            NSLog(@"检测到潜在死锁: 锁 %@ 被持有超过30秒", lockName);
            return YES;
        }
    }
    
    return NO;
}

- (NSArray *)getDeadlockReport {
    NSMutableArray *report = [NSMutableArray array];
    
    NSTimeInterval currentTime = [[NSDate date] timeIntervalSince1970];
    
    for (NSString *lockName in self.locks) {
        NSDictionary *lockInfo = self.locks[lockName];
        NSTimeInterval createdAt = [lockInfo[@"createdAt"] doubleValue];
        NSTimeInterval holdTime = currentTime - createdAt;
        
        if (holdTime > 10.0) { // 10秒以上的锁持有
            [report addObject:@{
                @"lockName": lockName,
                @"type": lockInfo[@"type"],
                @"holdTime": @(holdTime),
                @"severity": holdTime > 30.0 ? @"High" : @"Medium"
            }];
        }
    }
    
    return report;
}

@end

@interface MultithreadingPerformanceOptimizer : NSObject

@property (nonatomic, strong) NSMutableDictionary *performanceMetrics;
@property (nonatomic, strong) NSMutableArray *optimizationSuggestions;
@property (nonatomic, strong) NSTimer *monitoringTimer;
@property (nonatomic, assign) BOOL isMonitoring;

+ (instancetype)sharedOptimizer;

// 性能监控
- (void)startPerformanceMonitoring;
- (void)stopPerformanceMonitoring;
- (void)recordThreadCreation:(NSString *)threadName;
- (void)recordTaskExecution:(NSString *)taskName duration:(NSTimeInterval)duration;

// 性能分析
- (NSDictionary *)getPerformanceReport;
- (NSArray *)analyzeBottlenecks;
- (NSArray *)generateOptimizationSuggestions;

// 自动优化
- (void)optimizeQueueConfiguration;
- (void)balanceWorkload;
- (void)adjustConcurrencyLimits;

// 资源管理
- (void)monitorMemoryUsage;
- (void)detectResourceLeaks;
- (void)cleanupIdleResources;

@end

@implementation MultithreadingPerformanceOptimizer

+ (instancetype)sharedOptimizer {
    static MultithreadingPerformanceOptimizer *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.optimizationSuggestions = [NSMutableArray array];
        self.isMonitoring = NO;
    }
    return self;
}

- (void)startPerformanceMonitoring {
    if (!self.isMonitoring) {
        NSLog(@"开始多线程性能监控");
        self.isMonitoring = YES;
        
        // 每5秒收集一次性能数据
        self.monitoringTimer = [NSTimer scheduledTimerWithTimeInterval:5.0
                                                               target:self
                                                             selector:@selector(collectPerformanceData)
                                                             userInfo:nil
                                                              repeats:YES];
        
        // 初始化性能指标
        self.performanceMetrics[@"startTime"] = @([[NSDate date] timeIntervalSince1970]);
        self.performanceMetrics[@"threadCount"] = @0;
        self.performanceMetrics[@"taskCount"] = @0;
        self.performanceMetrics[@"totalExecutionTime"] = @0;
        self.performanceMetrics[@"memoryUsage"] = [NSMutableArray array];
        self.performanceMetrics[@"cpuUsage"] = [NSMutableArray array];
    }
}

- (void)stopPerformanceMonitoring {
    if (self.isMonitoring) {
        NSLog(@"停止多线程性能监控");
        self.isMonitoring = NO;
        
        [self.monitoringTimer invalidate];
        self.monitoringTimer = nil;
        
        // 生成最终报告
        [self generateFinalReport];
    }
}

- (void)collectPerformanceData {
    if (!self.isMonitoring) return;
    
    // 收集内存使用情况
    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) {
        NSNumber *memoryUsage = @(info.resident_size / 1024.0 / 1024.0); // MB
        NSMutableArray *memoryArray = self.performanceMetrics[@"memoryUsage"];
        [memoryArray addObject:@{
            @"timestamp": @([[NSDate date] timeIntervalSince1970]),
            @"memory": memoryUsage
        }];
        
        NSLog(@"当前内存使用: %.2f MB", [memoryUsage doubleValue]);
    }
    
    // 收集线程数量
    thread_array_t threadList;
    mach_msg_type_number_t threadCount;
    
    if (task_threads(mach_task_self(), &threadList, &threadCount) == KERN_SUCCESS) {
        self.performanceMetrics[@"currentThreadCount"] = @(threadCount);
        NSLog(@"当前线程数量: %d", threadCount);
        
        vm_deallocate(mach_task_self(), (vm_address_t)threadList, threadCount * sizeof(thread_t));
    }
}

- (void)recordThreadCreation:(NSString *)threadName {
    NSLog(@"记录线程创建: %@", threadName);
    
    NSInteger threadCount = [self.performanceMetrics[@"threadCount"] integerValue] + 1;
    self.performanceMetrics[@"threadCount"] = @(threadCount);
    
    // 记录线程创建历史
    NSMutableArray *threadHistory = self.performanceMetrics[@"threadHistory"];
    if (!threadHistory) {
        threadHistory = [NSMutableArray array];
        self.performanceMetrics[@"threadHistory"] = threadHistory;
    }
    
    [threadHistory addObject:@{
        @"name": threadName,
        @"createdAt": @([[NSDate date] timeIntervalSince1970]),
        @"type": @"creation"
    }];
}

- (void)recordTaskExecution:(NSString *)taskName duration:(NSTimeInterval)duration {
    NSLog(@"记录任务执行: %@，耗时: %.3f秒", taskName, duration);
    
    NSInteger taskCount = [self.performanceMetrics[@"taskCount"] integerValue] + 1;
    NSTimeInterval totalTime = [self.performanceMetrics[@"totalExecutionTime"] doubleValue] + duration;
    
    self.performanceMetrics[@"taskCount"] = @(taskCount);
    self.performanceMetrics[@"totalExecutionTime"] = @(totalTime);
    
    // 记录任务执行历史
    NSMutableArray *taskHistory = self.performanceMetrics[@"taskHistory"];
    if (!taskHistory) {
        taskHistory = [NSMutableArray array];
        self.performanceMetrics[@"taskHistory"] = taskHistory;
    }
    
    [taskHistory addObject:@{
        @"name": taskName,
        @"duration": @(duration),
        @"executedAt": @([[NSDate date] timeIntervalSince1970])
    }];
    
    // 检查是否需要优化建议
    if (duration > 1.0) { // 超过1秒的任务
        [self.optimizationSuggestions addObject:@{
            @"type": @"slow_task",
            @"message": [NSString stringWithFormat:@"任务 %@ 执行时间过长: %.3f秒", taskName, duration],
            @"suggestion": @"考虑将任务分解为更小的子任务或使用后台队列"
        }];
    }
}

- (NSDictionary *)getPerformanceReport {
    NSMutableDictionary *report = [NSMutableDictionary dictionary];
    
    NSTimeInterval currentTime = [[NSDate date] timeIntervalSince1970];
    NSTimeInterval startTime = [self.performanceMetrics[@"startTime"] doubleValue];
    NSTimeInterval monitoringDuration = currentTime - startTime;
    
    report[@"monitoringDuration"] = @(monitoringDuration);
    report[@"totalThreadsCreated"] = self.performanceMetrics[@"threadCount"] ?: @0;
    report[@"totalTasksExecuted"] = self.performanceMetrics[@"taskCount"] ?: @0;
    report[@"totalExecutionTime"] = self.performanceMetrics[@"totalExecutionTime"] ?: @0;
    report[@"currentThreadCount"] = self.performanceMetrics[@"currentThreadCount"] ?: @0;
    
    // 计算平均值
    NSInteger taskCount = [self.performanceMetrics[@"taskCount"] integerValue];
    if (taskCount > 0) {
        NSTimeInterval totalTime = [self.performanceMetrics[@"totalExecutionTime"] doubleValue];
        report[@"averageTaskDuration"] = @(totalTime / taskCount);
    }
    
    // 内存使用统计
    NSArray *memoryUsage = self.performanceMetrics[@"memoryUsage"];
    if (memoryUsage.count > 0) {
        double totalMemory = 0;
        double maxMemory = 0;
        for (NSDictionary *entry in memoryUsage) {
            double memory = [entry[@"memory"] doubleValue];
            totalMemory += memory;
            if (memory > maxMemory) {
                maxMemory = memory;
            }
        }
        report[@"averageMemoryUsage"] = @(totalMemory / memoryUsage.count);
        report[@"peakMemoryUsage"] = @(maxMemory);
    }
    
    report[@"optimizationSuggestions"] = [self.optimizationSuggestions copy];
    
    return report;
}

- (NSArray *)analyzeBottlenecks {
    NSMutableArray *bottlenecks = [NSMutableArray array];
    
    // 分析任务执行时间
    NSArray *taskHistory = self.performanceMetrics[@"taskHistory"];
    if (taskHistory) {
        NSMutableDictionary *taskStats = [NSMutableDictionary dictionary];
        
        for (NSDictionary *task in taskHistory) {
            NSString *taskName = task[@"name"];
            NSTimeInterval duration = [task[@"duration"] doubleValue];
            
            NSMutableArray *durations = taskStats[taskName];
            if (!durations) {
                durations = [NSMutableArray array];
                taskStats[taskName] = durations;
            }
            [durations addObject:@(duration)];
        }
        
        // 找出平均执行时间最长的任务
        for (NSString *taskName in taskStats) {
            NSArray *durations = taskStats[taskName];
            double totalDuration = 0;
            for (NSNumber *duration in durations) {
                totalDuration += [duration doubleValue];
            }
            double averageDuration = totalDuration / durations.count;
            
            if (averageDuration > 0.5) { // 平均超过0.5秒
                [bottlenecks addObject:@{
                    @"type": @"slow_task",
                    @"taskName": taskName,
                    @"averageDuration": @(averageDuration),
                    @"executionCount": @(durations.count),
                    @"severity": averageDuration > 2.0 ? @"High" : @"Medium"
                }];
            }
        }
    }
    
    // 分析内存使用趋势
    NSArray *memoryUsage = self.performanceMetrics[@"memoryUsage"];
    if (memoryUsage.count > 10) {
        // 检查内存是否持续增长
        double firstMemory = [memoryUsage.firstObject[@"memory"] doubleValue];
        double lastMemory = [memoryUsage.lastObject[@"memory"] doubleValue];
        
        if (lastMemory > firstMemory * 1.5) { // 内存增长超过50%
            [bottlenecks addObject:@{
                @"type": @"memory_growth",
                @"initialMemory": @(firstMemory),
                @"currentMemory": @(lastMemory),
                @"growthRate": @((lastMemory - firstMemory) / firstMemory * 100),
                @"severity": @"High"
            }];
        }
    }
    
    return bottlenecks;
}

- (NSArray *)generateOptimizationSuggestions {
    NSMutableArray *suggestions = [NSMutableArray array];
    
    NSArray *bottlenecks = [self analyzeBottlenecks];
    
    for (NSDictionary *bottleneck in bottlenecks) {
        NSString *type = bottleneck[@"type"];
        
        if ([type isEqualToString:@"slow_task"]) {
            [suggestions addObject:@{
                @"category": @"Performance",
                @"priority": @"High",
                @"suggestion": [NSString stringWithFormat:@"优化任务 %@：考虑异步执行或分解为更小的子任务", bottleneck[@"taskName"]],
                @"implementation": @"使用GCD的并发队列或NSOperation的依赖关系"
            }];
        } else if ([type isEqualToString:@"memory_growth"]) {
            [suggestions addObject:@{
                @"category": @"Memory",
                @"priority": @"Critical",
                @"suggestion": @"检测到内存持续增长，可能存在内存泄漏",
                @"implementation": @"使用Instruments检查内存泄漏，确保正确释放资源"
            }];
        }
    }
    
    // 基于线程数量的建议
    NSInteger currentThreadCount = [self.performanceMetrics[@"currentThreadCount"] integerValue];
    if (currentThreadCount > 20) {
        [suggestions addObject:@{
            @"category": @"Threading",
            @"priority": @"Medium",
            @"suggestion": [NSString stringWithFormat:@"当前线程数量过多(%ld)，可能影响性能", (long)currentThreadCount],
            @"implementation": @"使用线程池或减少并发操作数量"
        }];
    }
    
    return suggestions;
}

- (void)optimizeQueueConfiguration {
    NSLog(@"执行队列配置优化...");
    
    // 获取系统信息
    NSInteger processorCount = [[NSProcessInfo processInfo] processorCount];
    
    // 建议的最大并发数
    NSInteger recommendedConcurrency = processorCount * 2;
    
    NSLog(@"系统处理器数量: %ld，建议最大并发数: %ld", (long)processorCount, (long)recommendedConcurrency);
    
    // 这里可以调整现有队列的配置
    // 实际实现中需要访问具体的队列实例
}

- (void)balanceWorkload {
    NSLog(@"执行工作负载均衡...");
    
    // 分析任务分布
    NSArray *taskHistory = self.performanceMetrics[@"taskHistory"];
    if (taskHistory.count > 0) {
        // 统计不同类型任务的执行情况
        NSMutableDictionary *taskTypeStats = [NSMutableDictionary dictionary];
        
        for (NSDictionary *task in taskHistory) {
            NSString *taskName = task[@"name"];
            NSTimeInterval duration = [task[@"duration"] doubleValue];
            
            NSMutableDictionary *stats = taskTypeStats[taskName];
            if (!stats) {
                stats = [@{@"count": @0, @"totalDuration": @0} mutableCopy];
                taskTypeStats[taskName] = stats;
            }
            
            stats[@"count"] = @([stats[@"count"] integerValue] + 1);
            stats[@"totalDuration"] = @([stats[@"totalDuration"] doubleValue] + duration);
        }
        
        NSLog(@"任务类型统计: %@", taskTypeStats);
    }
}

- (void)adjustConcurrencyLimits {
    NSLog(@"调整并发限制...");
    
    // 基于当前性能指标调整并发限制
    NSInteger currentThreadCount = [self.performanceMetrics[@"currentThreadCount"] integerValue];
    NSArray *memoryUsage = self.performanceMetrics[@"memoryUsage"];
    
    if (memoryUsage.count > 0) {
        double currentMemory = [memoryUsage.lastObject[@"memory"] doubleValue];
        
        if (currentMemory > 100.0) { // 内存使用超过100MB
            NSLog(@"内存使用过高(%.2f MB)，建议降低并发数", currentMemory);
        } else if (currentThreadCount < 5 && currentMemory < 50.0) {
            NSLog(@"资源使用较低，可以适当增加并发数");
        }
    }
}

- (void)monitorMemoryUsage {
    // 已在collectPerformanceData中实现
}

- (void)detectResourceLeaks {
    NSLog(@"检测资源泄漏...");
    
    // 检查线程数量是否异常增长
    NSArray *threadHistory = self.performanceMetrics[@"threadHistory"];
    if (threadHistory.count > 100) {
        NSLog(@"警告: 线程创建数量过多(%lu)，可能存在线程泄漏", (unsigned long)threadHistory.count);
    }
    
    // 检查内存使用趋势
    NSArray *memoryUsage = self.performanceMetrics[@"memoryUsage"];
    if (memoryUsage.count >= 10) {
        double firstMemory = [memoryUsage.firstObject[@"memory"] doubleValue];
        double lastMemory = [memoryUsage.lastObject[@"memory"] doubleValue];
        
        if (lastMemory > firstMemory * 2.0) {
            NSLog(@"警告: 内存使用增长过快，从%.2fMB增长到%.2fMB", firstMemory, lastMemory);
        }
    }
}

- (void)cleanupIdleResources {
    NSLog(@"清理空闲资源...");
    
    // 清理过期的性能数据
    NSTimeInterval currentTime = [[NSDate date] timeIntervalSince1970];
    NSTimeInterval cutoffTime = currentTime - 3600; // 保留1小时内的数据
    
    NSMutableArray *memoryUsage = self.performanceMetrics[@"memoryUsage"];
    NSPredicate *predicate = [NSPredicate predicateWithFormat:@"timestamp > %f", cutoffTime];
    NSArray *filteredMemory = [memoryUsage filteredArrayUsingPredicate:predicate];
    [memoryUsage removeAllObjects];
    [memoryUsage addObjectsFromArray:filteredMemory];
    
    NSLog(@"清理完成，保留了%lu条内存使用记录", (unsigned long)memoryUsage.count);
}

- (void)generateFinalReport {
    NSLog(@"=== 多线程性能监控最终报告 ===");
    
    NSDictionary *report = [self getPerformanceReport];
    
    NSLog(@"监控时长: %.2f秒", [report[@"monitoringDuration"] doubleValue]);
    NSLog(@"创建线程总数: %@", report[@"totalThreadsCreated"]);
    NSLog(@"执行任务总数: %@", report[@"totalTasksExecuted"]);
    NSLog(@"总执行时间: %.3f秒", [report[@"totalExecutionTime"] doubleValue]);
    NSLog(@"当前线程数: %@", report[@"currentThreadCount"]);
    
    if (report[@"averageTaskDuration"]) {
        NSLog(@"平均任务执行时间: %.3f秒", [report[@"averageTaskDuration"] doubleValue]);
    }
    
    if (report[@"averageMemoryUsage"]) {
        NSLog(@"平均内存使用: %.2fMB", [report[@"averageMemoryUsage"] doubleValue]);
        NSLog(@"峰值内存使用: %.2fMB", [report[@"peakMemoryUsage"] doubleValue]);
    }
    
    NSArray *suggestions = report[@"optimizationSuggestions"];
    if (suggestions.count > 0) {
        NSLog(@"优化建议:");
        for (NSDictionary *suggestion in suggestions) {
            NSLog(@"  - %@: %@", suggestion[@"type"], suggestion[@"message"]);
        }
    }
}

@end