JavaScript异步编程陷阱：内存泄漏与事件循环阻塞实战解决方案

一、Promise内存泄漏与引用管理

1. Promise链未完成导致的内存泄漏

未正确处理的Promise链会持续持有对象引用：

// Promise内存泄漏检测类
class PromiseMemoryLeakDetector {
    constructor() {
        this.pendingPromises = new Set();
        this.leakThreshold = 1000; // 未完成Promise数量阈值
        this.setupMonitoring();
    }
    
    setupMonitoring() {
        // 重写Promise构造函数进行监控
        const OriginalPromise = Promise;
        
        global.Promise = function(executor) {
            const promise = new OriginalPromise(executor);
            const stack = new Error().stack;
            
            // 记录创建的Promise
            this.pendingPromises.add({
                promise,
                created: Date.now(),
                stack: stack.split('\n').slice(1, 4).join('\n') // 保留前3行堆栈
            });
            
            // Promise完成后自动清理
            promise.finally(() => {
                this.pendingPromises.delete(promise);
            });
            
            return promise;
        };
        
        // 继承静态方法
        Object.setPrototypeOf(global.Promise, OriginalPromise);
        global.Promise.prototype = OriginalPromise.prototype;
        
        // 设置定期检查
        this.monitorInterval = setInterval(() => {
            this.checkForLeaks();
        }, 10000);
    }
    
    checkForLeaks() {
        const now = Date.now();
        const oldPromises = [];
        
        for (const { promise, created, stack } of this.pendingPromises) {
            if (now - created > 30000) { // 超过30秒未完成
                oldPromises.push({ promise, created, stack });
            }
        }
        
        if (oldPromises.length > this.leakThreshold) {
            console.warn(`⚠️ 检测到 ${oldPromises.length} 个可能泄漏的Promise`);
            oldPromises.slice(0, 5).forEach(({ created, stack }, index) => {
                console.warn(`泄漏Promise ${index + 1}: 创建于 ${new Date(created).toISOString()}`);
                console.warn(`创建堆栈:\n${stack}`);
            });
        }
    }
    
    destroy() {
        clearInterval(this.monitorInterval);
    }
}

// 泄漏示例：未完成的Promise链
function createLeakyPromises() {
    const leakedReferences = [];
    
    for (let i = 0; i < 1000; i++) {
        // 这个Promise永远不会resolve或reject
        new Promise((resolve) => {
            // 持有外部引用
            leakedReferences.push({
                data: new Array(1000).fill('泄漏数据'),
                resolve
            });
            // 故意不调用resolve/reject
        });
    }
    
    return leakedReferences;
}

// 修复方案：超时控制 + 强制清理
class SafePromiseWithTimeout {
    static create(executor, timeout = 5000) {
        return new Promise((resolve, reject) => {
            let completed = false;
            
            const timeoutId = setTimeout(() => {
                if (!completed) {
                    completed = true;
                    reject(new Error(`Promise超时: ${timeout}ms`));
                }
            }, timeout);
            
            const cleanup = () => {
                clearTimeout(timeoutId);
                if (!completed) {
                    completed = true;
                }
            };
            
            try {
                executor(
                    (value) => {
                        cleanup();
                        resolve(value);
                    },
                    (error) => {
                        cleanup();
                        reject(error);
                    }
                );
            } catch (error) {
                cleanup();
                reject(error);
            }
        });
    }
}

// 使用安全Promise
async function safeAsyncOperation() {
    try {
        const result = await SafePromiseWithTimeout.create((resolve) => {
            // 异步操作
            someAsyncOperation().then(resolve);
        }, 3000);
        
        return result;
    } catch (error) {
        console.error('操作失败:', error.message);
        return null;
    }
}

2. 异步闭包中的循环引用问题

async函数中常见的循环引用陷阱：

// 循环引用泄漏示例
class LeakyAsyncService {
    constructor() {
        this.cache = new Map();
        this.setupPolling();
    }
    
    setupPolling() {
        // 定时器保持对this的引用
        setInterval(async () => {
            // 这个async函数形成闭包，引用this
            const data = await this.fetchData();
            this.processData(data);
        }, 1000);
    }
    
    async fetchData() {
        return new Array(1000).fill('模拟数据');
    }
    
    processData(data) {
        this.cache.set(Date.now(), data);
    }
    
    // 即使调用destroy，定时器仍然运行，实例无法被回收
    destroy() {
        // 缺少clearInterval，泄漏继续
    }
}

// 修复方案：可控的异步生命周期管理
class SafeAsyncService {
    constructor() {
        this.cache = new Map();
        this.isDestroyed = false;
        this.intervals = new Set();
        this.pendingOperations = new Set();
        this.setupPolling();
    }
    
    setupPolling() {
        const intervalId = setInterval(() => {
            if (this.isDestroyed) return;
            
            const operation = this.safeFetchAndProcess();
            this.pendingOperations.add(operation);
            
            operation.finally(() => {
                this.pendingOperations.delete(operation);
            });
        }, 1000);
        
        this.intervals.add(intervalId);
    }
    
    async safeFetchAndProcess() {
        if (this.isDestroyed) return;
        
        try {
            const data = await this.fetchData();
            if (!this.isDestroyed) {
                this.processData(data);
            }
        } catch (error) {
            if (!this.isDestroyed) {
                console.error('数据处理失败:', error);
            }
        }
    }
    
    async fetchData() {
        // 模拟异步数据获取
        return new Promise(resolve => {
            setTimeout(() => {
                resolve(new Array(1000).fill('安全数据'));
            }, 100);
        });
    }
    
    processData(data) {
        this.cache.set(Date.now(), data);
        
        // 自动清理旧缓存
        const keys = [...this.cache.keys()].sort((a, b) => b - a);
        if (keys.length > 100) {
            for (let i = 100; i < keys.length; i++) {
                this.cache.delete(keys[i]);
            }
        }
    }
    
    // 安全的销毁方法
    async destroy() {
        this.isDestroyed = true;
        
        // 清理所有定时器
        for (const intervalId of this.intervals) {
            clearInterval(intervalId);
        }
        this.intervals.clear();
        
        // 等待进行中的操作完成
        await Promise.allSettled([...this.pendingOperations]);
        
        // 清理缓存和引用
        this.cache.clear();
        
        console.log('服务已安全销毁');
    }
}

// 使用WeakRef避免强引用
class WeakAsyncManager {
    constructor(target) {
        this.weakTarget = new WeakRef(target);
        this.setupCleanup();
    }
    
    setupCleanup() {
        // 使用FinalizationRegistry监听目标对象被GC
        this.registry = new FinalizationRegistry(() => {
            this.cleanup();
        });
        
        this.registry.register(this.weakTarget, 'async-manager-target');
    }
    
    async executeSafe(callback) {
        const target = this.weakTarget.deref();
        if (!target) {
            throw new Error('目标对象已被销毁');
        }
        
        return callback(target);
    }
    
    cleanup() {
        console.log('目标对象已被垃圾回收，清理异步管理器');
        if (this.registry) {
            this.registry.unregister(this);
        }
    }
}

二、事件循环阻塞与性能优化

1. 微任务队列过载问题

大量Promise同时解析导致的性能问题：

// 微任务队列压力测试
class MicrotaskPressureTester {
    static async testMicrotaskOverload() {
        console.time('微任务压力测试');
        
        const promises = [];
        
        // 创建大量立即解析的Promise
        for (let i = 0; i < 50000; i++) {
            promises.push(Promise.resolve({
                id: i,
                data: new Array(100).fill('test-data')
            }));
        }
        
        // 这会导致微任务队列被淹没
        const results = await Promise.all(promises);
        
        console.timeEnd('微任务压力测试');
        console.log(`处理了 ${results.length} 个Promise`);
        
        return results;
    }
    
    // 优化方案：分批次处理
    static async processInBatches(items, processor, batchSize = 1000) {
        const results = [];
        
        for (let i = 0; i < items.length; i += batchSize) {
            const batch = items.slice(i, i + batchSize);
            
            // 每批次使用Promise.all
            const batchPromises = batch.map(item => processor(item));
            const batchResults = await Promise.all(batchPromises);
            
            results.push(...batchResults);
            
            // 给事件循环喘息的机会
            if (i % (batchSize * 10) === 0) {
                await new Promise(resolve => setTimeout(resolve, 0));
            }
            
            console.log(`已完成批次: ${i / batchSize + 1}/${Math.ceil(items.length / batchSize)}`);
        }
        
        return results;
    }
    
    // 更精细的流量控制
    static createAsyncQueue(concurrency = 5) {
        const queue = [];
        let running = 0;
        
        const runNext = async () => {
            if (running >= concurrency || queue.length === 0) {
                return;
            }
            
            running++;
            const { task, resolve, reject } = queue.shift();
            
            try {
                const result = await task();
                resolve(result);
            } catch (error) {
                reject(error);
            } finally {
                running--;
                runNext(); // 继续执行下一个
            }
        };
        
        return {
            add(task) {
                return new Promise((resolve, reject) => {
                    queue.push({ task, resolve, reject });
                    runNext();
                });
            },
            
            getStats() {
                return {
                    queueLength: queue.length,
                    running,
                    concurrency
                };
            }
        };
    }
}

// 性能对比测试
async function runPerformanceComparison() {
    const testData = new Array(20000).fill(null).map((_, i) => i);
    
    console.log('=== 异步处理性能对比 ===');
    
    // 测试1: 直接使用Promise.all（有风险）
    console.time('直接Promise.all');
    try {
        const directResults = await Promise.all(
            testData.map(async (item) => {
                // 模拟异步操作
                await new Promise(resolve => setTimeout(resolve, 1));
                return item * 2;
            })
        );
        console.timeEnd('直接Promise.all');
    } catch (error) {
        console.timeEnd('直接Promise.all');
        console.error('直接Promise.all失败:', error);
    }
    
    // 测试2: 分批次处理
    console.time('分批次处理');
    const batchResults = await MicrotaskPressureTester.processInBatches(
        testData,
        async (item) => {
            await new Promise(resolve => setTimeout(resolve, 1));
            return item * 2;
        },
        1000
    );
    console.timeEnd('分批次处理');
    
    // 测试3: 异步队列控制
    console.time('异步队列控制');
    const queue = MicrotaskPressureTester.createAsyncQueue(10);
    const queueResults = await Promise.all(
        testData.map(item => queue.add(async () => {
            await new Promise(resolve => setTimeout(resolve, 1));
            return item * 2;
        }))
    );
    console.timeEnd('异步队列控制');
}

// 运行测试
// runPerformanceComparison();

2. async/await性能陷阱与优化

错误使用async/await导致的性能问题：

// async/await常见性能陷阱
class AsyncAwaitAntiPatterns {
    // 陷阱1: 不必要的await串行化
    static async unnecessarySerialization() {
        const results = [];
        
        // 错误：不必要的串行执行
        for (const item of largeArray) {
            const result = await processItem(item); // 一个个等待
            results.push(result);
        }
        
        return results;
    }
    
    // 修复：并行执行
    static async properParallelization() {
        const promises = largeArray.map(item => processItem(item));
        return Promise.all(promises); // 并行执行
    }
    
    // 陷阱2: 在循环中创建不必要的Promise
    static async promiseCreationInLoop() {
        let result = 0;
        
        // 错误：每次循环都创建新Promise
        for (let i = 0; i < 1000; i++) {
            result += await new Promise(resolve => {
                setTimeout(() => resolve(i), 10);
            });
        }
        
        return result;
    }
    
    // 修复：批量处理
    static async batchedPromiseCreation() {
        const promises = [];
        
        for (let i = 0; i < 1000; i++) {
            promises.push(new Promise(resolve => {
                setTimeout(() => resolve(i), 10);
            }));
        }
        
        const results = await Promise.all(promises);
        return results.reduce((sum, val) => sum + val, 0);
    }
    
    // 陷阱3: 忘记错误处理的async函数
    static async unhandledAsyncErrors() {
        const tasks = [task1(), task2(), task3()];
        
        // 错误：如果某个Promise reject，整个操作失败
        const results = await Promise.all(tasks);
        return results;
    }
    
    // 修复：安全的错误处理
    static async safeAsyncExecution() {
        const tasks = [task1(), task2(), task3()];
        
        // 使用allSettled，不会因为单个失败而整体失败
        const results = await Promise.allSettled(tasks);
        
        const successful = results
            .filter(result => result.status === 'fulfilled')
            .map(result => result.value);
            
        const failed = results
            .filter(result => result.status === 'rejected')
            .map(result => result.reason);
        
        if (failed.length > 0) {
            console.warn(`${failed.length} 个任务失败:`, failed);
        }
        
        return successful;
    }
}

// 高级async/await优化模式
class AdvancedAsyncPatterns {
    // 1. 可取消的异步操作
    static createCancelableAsync(generatorFunction) {
        return function(...args) {
            const generator = generatorFunction(...args);
            let canceled = false;
            let cancelReason;
            
            const promise = new Promise((resolve, reject) => {
                async function next(prevResult) {
                    if (canceled) {
                        reject(new Error(`操作已取消: ${cancelReason}`));
                        return;
                    }
                    
                    try {
                        const { value, done } = generator.next(prevResult);
                        
                        if (done) {
                            resolve(value);
                            return;
                        }
                        
                        // 处理不同类型的值
                        if (value instanceof Promise) {
                            const result = await value;
                            next(result);
                        } else if (Array.isArray(value) && value.every(item => item instanceof Promise)) {
                            const results = await Promise.all(value);
                            next(results);
                        } else {
                            next(value);
                        }
                    } catch (error) {
                        reject(error);
                    }
                }
                
                next();
            });
            
            promise.cancel = (reason = '用户取消') => {
                canceled = true;
                cancelReason = reason;
            };
            
            return promise;
        };
    }
    
    // 2. 带重试的异步操作
    static async withRetry(operation, maxRetries = 3, delay = 1000) {
        let lastError;
        
        for (let attempt = 1; attempt <= maxRetries; attempt++) {
            try {
                return await operation();
            } catch (error) {
                lastError = error;
                console.warn(`尝试 ${attempt}/${maxRetries} 失败:`, error.message);
                
                if (attempt < maxRetries) {
                    console.log(`等待 ${delay}ms 后重试...`);
                    await new Promise(resolve => setTimeout(resolve, delay));
                    delay *= 2; // 指数退避
                }
            }
        }
        
        throw new Error(`所有重试尝试均失败: ${lastError.message}`);
    }
    
    // 3. 异步操作的依赖管理
    static createAsyncDependencyManager() {
        const dependencies = new Map();
        const waiting = new Map();
        
        return {
            async register(name, factory) {
                if (dependencies.has(name)) {
                    return dependencies.get(name);
                }
                
                if (waiting.has(name)) {
                    return waiting.get(name);
                }
                
                const promise = factory().then(result => {
                    dependencies.set(name, result);
                    waiting.delete(name);
                    return result;
                });
                
                waiting.set(name, promise);
                return promise;
            },
            
            async get(name) {
                if (dependencies.has(name)) {
                    return dependencies.get(name);
                }
                
                if (waiting.has(name)) {
                    return waiting.get(name);
                }
                
                throw new Error(`依赖 ${name} 未注册`);
            },
            
            has(name) {
                return dependencies.has(name) || waiting.has(name);
            }
        };
    }
}

// 使用示例
async function demonstrateAdvancedPatterns() {
    const dependencyManager = AdvancedAsyncPatterns.createAsyncDependencyManager();
    
    // 注册异步依赖
    dependencyManager.register('database', async () => {
        console.log('初始化数据库连接...');
        await new Promise(resolve => setTimeout(resolve, 1000));
        return { connection: '模拟数据库连接' };
    });
    
    dependencyManager.register('cache', async () => {
        console.log('初始化缓存...');
        const db = await dependencyManager.get('database');
        await new Promise(resolve => setTimeout(resolve, 500));
        return { 
            client: '模拟缓存客户端',
            dbConnection: db.connection
        };
    });
    
    // 使用依赖
    try {
        const cache = await dependencyManager.get('cache');
        console.log('缓存服务就绪:', cache);
    } catch (error) {
        console.error('初始化失败:', error);
    }
}

三、生产环境异步监控与调试

1. 异步堆栈追踪增强

解决异步代码中堆栈信息丢失的问题：

// 异步堆栈追踪增强
class AsyncStackTracer {
    static enableAsyncHooks() {
        if (typeof process === 'undefined' || !process.env.NODE_ENV === 'development') {
            return;
        }
        
        // Node.js环境使用async_hooks
        const async_hooks = require('async_hooks');
        
        const stacks = new Map();
        
        const hook = async_hooks.createHook({
            init(asyncId, type, triggerAsyncId) {
                if (type === 'PROMISE' || type === 'TIMERWRAP') {
                    const stack = new Error().stack;
                    stacks.set(asyncId, {
                        type,
                        stack: stack.split('\n').slice(2).join('\n'), // 移除前两行
                        timestamp: Date.now()
                    });
                }
            },
            
            destroy(asyncId) {
                stacks.delete(asyncId);
            }
        });
        
        hook.enable();
        
        // 重写Promise以便捕获更多信息
        const OriginalPromise = Promise;
        
        global.Promise = function(executor) {
            const stack = new Error().stack;
            const promise = new OriginalPromise(executor);
            
            // 存储创建堆栈
            promise._creationStack = stack;
            
            return promise;
        };
        
        Object.setPrototypeOf(global.Promise, OriginalPromise);
        global.Promise.prototype = OriginalPromise.prototype;
        
        return {
            getStacks: () => new Map(stacks),
            disable: () => hook.disable()
        };
    }
    
    // 浏览器环境下的堆栈追踪
    static enhanceBrowserStackTraces() {
        if (typeof window === 'undefined') return;
        
        const originalPromise = window.Promise;
        
        window.Promise = function(executor) {
            const stack = new Error().stack;
            const promise = new originalPromise(executor);
            
            // 添加异步操作标识
            promise._asyncContext = {
                creationTime: Date.now(),
                creationStack: stack
            };
            
            return promise;
        };
        
        // 复制静态方法
        Object.keys(originalPromise).forEach(key => {
            window.Promise[key] = originalPromise[key];
        });
        
        window.Promise.prototype = originalPromise.prototype;
    }
}

// 异步性能监控
class AsyncPerformanceMonitor {
    constructor() {
        this.metrics = {
            pendingPromises: 0,
            completedPromises: 0,
            averageCompletionTime: 0,
            slowOperations: []
        };
        
        this.operations = new Map();
        this.setupMonitoring();
    }
    
    setupMonitoring() {
        const OriginalPromise = Promise;
        
        global.Promise = function(executor) {
            this.metrics.pendingPromises++;
            const operationId = Symbol('async-op');
            const startTime = performance.now();
            
            this.operations.set(operationId, {
                startTime,
                stack: new Error().stack
            });
            
            const wrappedExecutor = (resolve, reject) => {
                const wrappedResolve = (value) => {
                    this.recordCompletion(operationId, true);
                    resolve(value);
                };
                
                const wrappedReject = (reason) => {
                    this.recordCompletion(operationId, false);
                    reject(reason);
                };
                
                executor(wrappedResolve, wrappedReject);
            };
            
            return new OriginalPromise(wrappedExecutor);
        };
        
        Object.setPrototypeOf(global.Promise, OriginalPromise);
        global.Promise.prototype = OriginalPromise.prototype;
    }
    
    recordCompletion(operationId, success) {
        const operation = this.operations.get(operationId);
        if (!operation) return;
        
        const endTime = performance.now();
        const duration = endTime - operation.startTime;
        
        this.metrics.pendingPromises--;
        this.metrics.completedPromises++;
        
        // 更新平均完成时间
        this.metrics.averageCompletionTime = 
            (this.metrics.averageCompletionTime * (this.metrics.completedPromises - 1) + duration) / 
            this.metrics.completedPromises;
        
        // 记录慢操作
        if (duration > 1000) { // 超过1秒算慢操作
            this.metrics.slowOperations.push({
                duration,
                stack: operation.stack,
                timestamp: Date.now()
            });
            
            // 只保留最近10个慢操作
            if (this.metrics.slowOperations.length > 10) {
                this.metrics.slowOperations.shift();
            }
        }
        
        this.operations.delete(operationId);
    }
    
    getMetrics() {
        return {
            ...this.metrics,
            operationsInProgress: this.operations.size
        };
    }
    
    // 生成性能报告
    generateReport() {
        const metrics = this.getMetrics();
        
        console.log('=== 异步性能报告 ===');
        console.log(`进行中的Promise: ${metrics.pendingPromises}`);
        console.log(`已完成的Promise: ${metrics.completedPromises}`);
        console.log(`平均完成时间: ${metrics.averageCompletionTime.toFixed(2)}ms`);
        console.log(`慢操作数量: ${metrics.slowOperations.length}`);
        
        if (metrics.slowOperations.length > 0) {
            console.log('\n最近慢操作:');
            metrics.slowOperations.forEach((op, index) => {
                console.log(`${index + 1}. 耗时: ${op.duration.toFixed(2)}ms`);
                console.log(`   堆栈: ${op.stack.split('\n').slice(1, 4).join(' -> ')}`);
            });
        }
        
        return metrics;
    }
}

四、真实场景异步优化案例

1. 大数据分页加载优化

优化大量数据的分页异步加载：

class OptimizedPaginatedLoader {
    constructor(apiEndpoint, pageSize = 50) {
        this.apiEndpoint = apiEndpoint;
        this.pageSize = pageSize;
        this.cache = new Map();
        this.prefetchQueue = new Set();
        this.currentRequests = new Map();
        this.stats = {
            cacheHits: 0,
            apiCalls: 0,
            prefetchHits: 0
        };
    }
    
    async loadPage(pageNumber) {
        // 检查缓存
        const cacheKey = `page-${pageNumber}`;
        if (this.cache.has(cacheKey)) {
            this.stats.cacheHits++;
            return this.cache.get(cacheKey);
        }
        
        // 检查是否已经在请求中
        if (this.currentRequests.has(cacheKey)) {
            return this.currentRequests.get(cacheKey);
        }
        
        // 创建新的请求
        this.stats.apiCalls++;
        const requestPromise = this.fetchPageFromAPI(pageNumber);
        this.currentRequests.set(cacheKey, requestPromise);
        
        try {
            const data = await requestPromise;
            this.cache.set(cacheKey, data);
            
            // 预加载相邻页面
            this.prefetchAdjacentPages(pageNumber);
            
            return data;
        } finally {
            this.currentRequests.delete(cacheKey);
        }
    }
    
    async fetchPageFromAPI(pageNumber) {
        // 模拟API调用
        await new Promise(resolve => setTimeout(resolve, 100 + Math.random() * 100));
        
        const startId = (pageNumber - 1) * this.pageSize;
        return {
            page: pageNumber,
            data: new Array(this.pageSize).fill(null).map((_, index) => ({
                id: startId + index,
                name: `项目 ${startId + index}`,
                value: Math.random() * 1000
            })),
            hasNext: true
        };
    }
    
    prefetchAdjacentPages(currentPage) {
        const pagesToPrefetch = [currentPage + 1, currentPage + 2];
        
        for (const page of pagesToPrefetch) {
            if (!this.cache.has(`page-${page}`) && !this.currentRequests.has(`page-${page}`)) {
                const prefetchPromise = this.loadPage(page).then(data => {
                    this.prefetchQueue.delete(prefetchPromise);
                    this.stats.prefetchHits++;
                    return data;
                });
                
                this.prefetchQueue.add(prefetchPromise);
            }
        }
    }
    
    // 智能预加载基于用户行为
    anticipateNextPages(currentPage, scrollDirection) {
        const lookAhead = scrollDirection === 'down' ? [1, 2, 3] : [-1, -2, -3];
        
        for (const delta of lookAhead) {
            const targetPage = currentPage + delta;
            if (targetPage > 0 && !this.cache.has(`page-${targetPage}`)) {
                this.loadPage(targetPage);
            }
        }
    }
    
    getStats() {
        return {
            ...this.stats,
            cacheSize: this.cache.size,
            pendingPrefetches: this.prefetchQueue.size,
            currentRequests: this.currentRequests.size
        };
    }
    
    clearCache() {
        this.cache.clear();
        this.prefetchQueue.clear();
        // 注意：不清理currentRequests，避免中断进行中的请求
    }
}

// 使用示例
async function demonstratePaginatedLoader() {
    const loader = new OptimizedPaginatedLoader('/api/items');
    
    // 模拟用户浏览
    console.log('加载第1页...');
    const page1 = await loader.loadPage(1);
    console.log('第1页数据:', page1.data.length, '条');
    
    console.log('加载第2页...');
    const page2 = await loader.loadPage(2);
    console.log('第2页数据:', page2.data.length, '条');
    
    console.log('统计信息:', loader.getStats());
    
    // 测试缓存
    console.log('再次加载第1页(应该命中缓存)...');
    const page1Again = await loader.loadPage(1);
    console.log('统计信息:', loader.getStats());
}

五、异步编程最佳实践总结

1. 性能优化检查清单

2. 生产环境监控配置

// 生产环境异步监控配置
class ProductionAsyncMonitor {
    static init() {
        const monitors = [];
        
        // 1. Promise泄漏监控
        if (process.env.NODE_ENV === 'production') {
            monitors.push(new PromiseMemoryLeakDetector());
        }
        
        // 2. 性能监控
        const performanceMonitor = new AsyncPerformanceMonitor();
        monitors.push(performanceMonitor);
        
        // 3. 定期报告
        setInterval(() => {
            const report = performanceMonitor.generateReport();
            
            // 发送到监控系统
            if (report.pendingPromises > 1000) {
                console.error('异步系统压力过大:', report);
            }
        }, 60000); // 每分钟检查一次
        
        return {
            disconnect: () => {
                monitors.forEach(monitor => {
                    if (monitor.destroy) monitor.destroy();
                });
            }
        };
    }
}

// 初始化监控
// const monitor = ProductionAsyncMonitor.init();

// 应用关闭时清理
// process.on('beforeExit', () => monitor.disconnect());

3. 异步代码质量规则

// ESLint等代码检查工具的推荐规则
const asyncBestPractices = {
    rules: {
        // 强制await在try-catch中
        'await-in-try-catch': 'error',
        
        // 禁止不必要的async
        'no-unnecessary-async': 'error',
        
        // 强制Promise错误处理
        'promise-catch': 'warn',
        
        // 禁止循环中创建Promise
        'no-promise-in-loop': 'error',
        
        // 强制使用Promise.allSettled而不是Promise.all
        'prefer-promise-allsettled': 'warn'
    },
    
    // 推荐的异步模式
    patterns: {
        // 错误处理
        safeAsync: `
            async function safeOperation() {
                try {
                    const result = await potentiallyFailingOperation();
                    return { success: true, data: result };
                } catch (error) {
                    return { success: false, error: error.message };
                }
            }
        `,
        
        // 并行执行
        parallelExecution: `
            async function processBatch(items) {
                const batches = [];
                for (let i = 0; i < items.length; i += BATCH_SIZE) {
                    batches.push(items.slice(i, i + BATCH_SIZE));
                }
                
                const results = [];
                for (const batch of batches) {
                    const batchResults = await Promise.all(
                        batch.map(item => processItem(item))
                    );
                    results.push(...batchResults);
                }
                
                return results;
            }
        `
    }
};

总结

JavaScript异步编程的性能优化需要系统化的方法和持续监控：

核心优化策略：

1. 🚨 内存管理：Promise泄漏检测、循环引用预防、及时清理
2. ⚡ 性能优化：微任务队列管理、避免阻塞、合理并行化
3. 🔧 错误处理：完善的异常捕获、重试机制、降级方案
4. 📊 监控调试：堆栈追踪增强、性能指标收集、实时告警

关键性能指标：

• 未完成Promise数量应保持稳定
• 微任务队列不应长时间积压
• 异步操作平均完成时间应在合理范围
• 内存使用不应持续增长

最佳实践优先级：

1. ✅ 正确性：确保异步逻辑正确，避免竞态条件
2. 🚀 性能：优化执行效率，减少不必要的等待
3. 💾 内存：预防泄漏，及时释放资源
4. 🔍 可维护性：清晰的代码结构，完善的错误处理

通过实施这些优化策略和监控方案，可以构建出高性能、可维护且稳定的JavaScript异步应用。