Dec 22 2017

Node.js高并发系统架构设计：事件循环优化、集群部署与内存泄漏检测

作者： 绝缘体..   发布： 2017-12-22 06:36   分类： 未分类   阅读：   抢沙发  
 
更多

Node.js高并发系统架构设计：事件循环优化、集群部署与内存泄漏检测

引言

在现代Web应用开发中，Node.js凭借其非阻塞I/O模型和事件驱动架构，成为了构建高并发系统的首选技术栈之一。然而，随着业务规模的增长和用户访问量的激增，如何设计一个稳定、高效且可扩展的Node.js高并发系统成为开发者面临的核心挑战。

本文将深入探讨Node.js高并发系统架构设计的关键要素，从底层的事件循环机制优化开始，逐步深入到多进程集群部署策略、内存泄漏检测与预防，以及错误处理机制设计等多个维度，为开发者提供一套完整的高并发系统构建指南。

事件循环机制优化

Node.js事件循环原理

Node.js的事件循环是其异步I/O模型的核心，理解并优化这一机制对于构建高性能应用至关重要。事件循环由多个阶段组成：定时器回调、待定回调、idle/prepare、轮询、检查、关闭回调等。

// 示例：事件循环阶段演示
const fs = require('fs');

console.log('1. 同步代码执行');

setTimeout(() => {
    console.log('4. setTimeout 回调');
}, 0);

fs.readFile('./example.txt', 'utf8', (err, data) => {
    console.log('3. 文件读取完成');
});

console.log('2. 同步代码执行完毕');

// 输出顺序：1 -> 2 -> 3 -> 4

事件循环优化策略

1. 避免长时间阻塞事件循环

长时间运行的同步操作会阻塞整个事件循环，导致后续任务无法及时处理。应该始终使用异步API或在worker线程中执行耗时操作。

// ❌ 错误做法 - 阻塞事件循环
function processLargeData() {
    // 模拟长时间计算
    let sum = 0;
    for (let i = 0; i < 1000000000; i++) {
        sum += i;
    }
    return sum;
}

// ✅ 正确做法 - 使用异步处理
async function processLargeDataAsync() {
    return new Promise((resolve) => {
        setImmediate(() => {
            let sum = 0;
            for (let i = 0; i < 1000000000; i++) {
                sum += i;
            }
            resolve(sum);
        });
    });
}

2. 合理设置定时器

过度使用setImmediate和setTimeout会影响事件循环性能。应该根据实际需求选择合适的定时器类型。

// 优化定时器使用
class OptimizedTimerManager {
    constructor() {
        this.timers = new Map();
        this.batchSize = 100;
    }

    // 批量处理定时器任务
    batchProcess(callbacks) {
        const batch = callbacks.slice(0, this.batchSize);
        const remaining = callbacks.slice(this.batchSize);
        
        batch.forEach(callback => callback());
        
        if (remaining.length > 0) {
            setImmediate(() => this.batchProcess(remaining));
        }
    }

    // 智能定时器调度
    smartSchedule(task, delay = 0) {
        if (delay === 0) {
            setImmediate(task);
        } else {
            setTimeout(task, delay);
        }
    }
}

3. 事件循环监控

通过监控事件循环延迟来评估系统性能，及时发现潜在问题。

// 事件循环延迟监控
class EventLoopMonitor {
    constructor() {
        this.metrics = {
            maxDelay: 0,
            avgDelay: 0,
            totalSamples: 0
        };
        this.sampleInterval = 1000; // 1秒采样一次
        this.startMonitoring();
    }

    startMonitoring() {
        let lastTimestamp = Date.now();
        let sampleCount = 0;
        let totalDelay = 0;

        const monitor = () => {
            const now = Date.now();
            const delay = now - lastTimestamp;
            
            if (delay > this.metrics.maxDelay) {
                this.metrics.maxDelay = delay;
            }
            
            totalDelay += delay;
            sampleCount++;
            
            if (sampleCount >= 10) { // 每10次采样计算平均值
                this.metrics.avgDelay = totalDelay / sampleCount;
                sampleCount = 0;
                totalDelay = 0;
                
                console.log(`Event Loop Metrics - Max: ${this.metrics.maxDelay}ms, Avg: ${this.metrics.avgDelay.toFixed(2)}ms`);
            }
            
            lastTimestamp = now;
            setTimeout(monitor, this.sampleInterval);
        };

        monitor();
    }

    getMetrics() {
        return this.metrics;
    }
}

// 使用示例
const monitor = new EventLoopMonitor();

多进程集群部署策略

Node.js集群模式概述

Node.js提供了cluster模块来实现多进程部署，充分利用多核CPU资源。每个工作进程都是独立的Node.js实例，共享相同的端口。

// 基础集群部署示例
const cluster = require('cluster');
const numCPUs = require('os').cpus().length;
const http = require('http');

if (cluster.isMaster) {
    console.log(`主进程 ${process.pid} 正在运行`);
    
    // 衍生工作进程
    for (let i = 0; i < numCPUs; i++) {
        cluster.fork();
    }
    
    cluster.on('exit', (worker, code, signal) => {
        console.log(`工作进程 ${worker.process.pid} 已退出`);
        // 自动重启工作进程
        cluster.fork();
    });
} else {
    // 工作进程
    const server = http.createServer((req, res) => {
        res.writeHead(200);
        res.end('Hello World\n');
    });
    
    server.listen(8000, () => {
        console.log(`工作进程 ${process.pid} 已启动`);
    });
}

高级集群配置

1. 负载均衡策略

默认情况下，Node.js集群使用轮询负载均衡策略。可以通过自定义负载均衡器来优化请求分发。

// 自定义负载均衡器
const cluster = require('cluster');
const http = require('http');
const os = require('os');

class CustomLoadBalancer {
    constructor() {
        this.workers = [];
        this.requestCount = new Map();
        this.maxWorkers = os.cpus().length;
    }

    addWorker(worker) {
        this.workers.push(worker);
        this.requestCount.set(worker.id, 0);
    }

    getNextWorker() {
        // 基于请求数量选择最空闲的工作进程
        let minRequests = Infinity;
        let selectedWorker = null;
        
        for (const [id, count] of this.requestCount.entries()) {
            if (count < minRequests) {
                minRequests = count;
                selectedWorker = this.workers.find(w => w.id === id);
            }
        }
        
        return selectedWorker;
    }

    incrementRequestCount(workerId) {
        const current = this.requestCount.get(workerId) || 0;
        this.requestCount.set(workerId, current + 1);
    }

    decrementRequestCount(workerId) {
        const current = this.requestCount.get(workerId) || 0;
        this.requestCount.set(workerId, Math.max(0, current - 1));
    }
}

const loadBalancer = new CustomLoadBalancer();

if (cluster.isMaster) {
    console.log(`主进程 ${process.pid} 正在运行`);
    
    for (let i = 0; i < os.cpus().length; i++) {
        const worker = cluster.fork();
        loadBalancer.addWorker(worker);
    }
    
    cluster.on('exit', (worker, code, signal) => {
        console.log(`工作进程 ${worker.process.pid} 已退出`);
        cluster.fork();
    });
} else {
    // 工作进程
    const server = http.createServer((req, res) => {
        // 记录请求
        loadBalancer.incrementRequestCount(cluster.worker.id);
        
        // 模拟处理时间
        setTimeout(() => {
            res.writeHead(200, { 'Content-Type': 'text/plain' });
            res.end(`Hello from worker ${cluster.worker.id}`);
            
            // 减少计数
            loadBalancer.decrementRequestCount(cluster.worker.id);
        }, 100);
    });
    
    server.listen(8000, () => {
        console.log(`工作进程 ${process.pid} 已启动`);
    });
}

2. 进程间通信优化

有效的进程间通信对于集群应用的性能至关重要。

// 进程间通信优化
const cluster = require('cluster');
const EventEmitter = require('events');

class ClusterEventManager extends EventEmitter {
    constructor() {
        super();
        this.messageQueue = [];
        this.isProcessing = false;
    }

    // 发送消息到其他进程
    sendMessage(targetWorkerId, message) {
        if (targetWorkerId === cluster.worker.id) {
            // 发送给自身
            this.emit('message', message);
        } else {
            // 发送给指定工作进程
            cluster.workers[targetWorkerId].send(message);
        }
    }

    // 批量处理消息
    batchProcess(messages) {
        if (this.isProcessing) {
            this.messageQueue.push(...messages);
            return;
        }

        this.isProcessing = true;
        messages.forEach(message => {
            this.emit('message', message);
        });
        
        // 清空队列
        this.messageQueue = [];
        this.isProcessing = false;
    }
}

const eventManager = new ClusterEventManager();

// 主进程
if (cluster.isMaster) {
    // 监听所有工作进程的消息
    Object.values(cluster.workers).forEach(worker => {
        worker.on('message', (message) => {
            console.log(`收到消息:`, message);
            // 广播给其他工作进程
            Object.values(cluster.workers).forEach(w => {
                if (w !== worker) {
                    w.send({ type: 'broadcast', data: message });
                }
            });
        });
    });
}

// 工作进程
if (cluster.isWorker) {
    // 注册消息处理器
    eventManager.on('message', (message) => {
        console.log(`工作进程 ${cluster.worker.id} 收到消息:`, message);
    });

    // 发送消息示例
    setInterval(() => {
        eventManager.sendMessage(cluster.worker.id, {
            timestamp: Date.now(),
            workerId: cluster.worker.id,
            type: 'heartbeat'
        });
    }, 5000);
}

3. 动态集群管理

支持动态调整工作进程数量，以适应不同的负载情况。

// 动态集群管理
const cluster = require('cluster');
const os = require('os');

class DynamicClusterManager {
    constructor(options = {}) {
        this.minWorkers = options.minWorkers || 1;
        this.maxWorkers = options.maxWorkers || os.cpus().length;
        this.targetLoad = options.targetLoad || 0.8;
        this.checkInterval = options.checkInterval || 5000;
        this.currentWorkers = 0;
        this.loadHistory = [];
        this.startMonitoring();
    }

    startMonitoring() {
        setInterval(() => {
            this.calculateSystemLoad();
            this.adjustWorkerCount();
        }, this.checkInterval);
    }

    calculateSystemLoad() {
        // 简化的负载计算
        const cpuUsage = this.getCpuUsage();
        const memoryUsage = process.memoryUsage();
        
        const load = {
            cpu: cpuUsage,
            memory: memoryUsage.rss,
            timestamp: Date.now()
        };
        
        this.loadHistory.push(load);
        if (this.loadHistory.length > 10) {
            this.loadHistory.shift();
        }
    }

    getCpuUsage() {
        // 简化版CPU使用率计算
        return Math.random(); // 实际应用中需要更精确的计算
    }

    adjustWorkerCount() {
        const avgLoad = this.calculateAverageLoad();
        
        if (avgLoad > this.targetLoad && this.currentWorkers < this.maxWorkers) {
            // 增加工作进程
            this.scaleUp();
        } else if (avgLoad < this.targetLoad * 0.5 && this.currentWorkers > this.minWorkers) {
            // 减少工作进程
            this.scaleDown();
        }
    }

    calculateAverageLoad() {
        if (this.loadHistory.length === 0) return 0;
        
        const sum = this.loadHistory.reduce((acc, load) => acc + load.cpu, 0);
        return sum / this.loadHistory.length;
    }

    scaleUp() {
        if (this.currentWorkers < this.maxWorkers) {
            const newWorker = cluster.fork();
            this.currentWorkers++;
            console.log(`新增工作进程，当前总数: ${this.currentWorkers}`);
        }
    }

    scaleDown() {
        if (this.currentWorkers > this.minWorkers) {
            const workerToKill = Object.values(cluster.workers)[0];
            if (workerToKill) {
                workerToKill.kill();
                this.currentWorkers--;
                console.log(`减少工作进程，当前总数: ${this.currentWorkers}`);
            }
        }
    }
}

// 使用动态集群管理
const clusterManager = new DynamicClusterManager({
    minWorkers: 2,
    maxWorkers: 8,
    targetLoad: 0.7,
    checkInterval: 3000
});

if (cluster.isMaster) {
    console.log(`动态集群管理已启动`);
    
    // 初始化工作进程
    for (let i = 0; i < 2; i++) {
        cluster.fork();
    }
    
    cluster.on('exit', (worker, code, signal) => {
        console.log(`工作进程 ${worker.process.pid} 已退出`);
        cluster.fork();
    });
}

内存泄漏检测与预防

内存泄漏常见场景分析

Node.js应用中的内存泄漏通常源于以下几个方面：

  1. 闭包引用：不正确的闭包使用导致对象无法被垃圾回收
  2. 事件监听器泄漏：重复添加事件监听器而不移除
  3. 全局变量：过多的全局变量积累
  4. 缓存不当：无限增长的缓存机制
// 内存泄漏示例
class MemoryLeakExample {
    constructor() {
        this.data = [];
        this.cache = new Map();
        this.listeners = [];
    }

    // ❌ 错误：每次调用都添加新的监听器
    addListenerWithError() {
        const listener = () => {
            console.log('事件触发');
        };
        process.on('SIGINT', listener); // 每次调用都会添加新监听器
        this.listeners.push(listener);
    }

    // ✅ 正确：使用唯一标识符管理监听器
    addListenerWithFix() {
        const listener = () => {
            console.log('事件触发');
        };
        
        // 先移除旧监听器
        process.removeListener('SIGINT', listener);
        // 添加新监听器
        process.on('SIGINT', listener);
    }

    // ❌ 错误：无限增长的缓存
    addToCache(key, value) {
        this.cache.set(key, value); // 缓存不会被清理
    }

    // ✅ 正确：带过期机制的缓存
    addToCacheWithExpiration(key, value, ttl = 300000) {
        const cacheEntry = {
            value,
            expires: Date.now() + ttl
        };
        this.cache.set(key, cacheEntry);
        
        // 定期清理过期项
        this.cleanupExpiredEntries();
    }

    cleanupExpiredEntries() {
        const now = Date.now();
        for (const [key, entry] of this.cache.entries()) {
            if (entry.expires <= now) {
                this.cache.delete(key);
            }
        }
    }
}

内存监控工具集成

1. 使用heapdump进行内存快照分析

// 内存监控工具
const heapdump = require('heapdump');
const v8 = require('v8');

class MemoryMonitor {
    constructor() {
        this.memoryStats = {
            rss: 0,
            heapTotal: 0,
            heapUsed: 0,
            external: 0
        };
        this.thresholds = {
            rss: 100 * 1024 * 1024, // 100MB
            heapUsed: 50 * 1024 * 1024 // 50MB
        };
        this.startMonitoring();
    }

    startMonitoring() {
        setInterval(() => {
            this.collectMemoryStats();
            this.checkThresholds();
        }, 5000);
    }

    collectMemoryStats() {
        const usage = process.memoryUsage();
        this.memoryStats = {
            rss: usage.rss,
            heapTotal: usage.heapTotal,
            heapUsed: usage.heapUsed,
            external: usage.external,
            arrayBuffers: usage.arrayBuffers
        };
        
        console.log('内存使用统计:', this.memoryStats);
    }

    checkThresholds() {
        const stats = this.memoryStats;
        
        if (stats.rss > this.thresholds.rss) {
            console.warn(`RSS内存超过阈值: ${this.formatBytes(stats.rss)}`);
            this.takeHeapDump('rss_threshold_exceeded');
        }
        
        if (stats.heapUsed > this.thresholds.heapUsed) {
            console.warn(`堆内存使用超过阈值: ${this.formatBytes(stats.heapUsed)}`);
            this.takeHeapDump('heap_threshold_exceeded');
        }
    }

    takeHeapDump(reason) {
        const filename = `heapdump-${Date.now()}-${reason}.heapsnapshot`;
        heapdump.writeSnapshot(filename, (err, filename) => {
            if (err) {
                console.error('堆转储失败:', err);
            } else {
                console.log(`堆转储已保存: ${filename}`);
            }
        });
    }

    formatBytes(bytes) {
        const units = ['B', 'KB', 'MB', 'GB'];
        let unitIndex = 0;
        let size = bytes;
        
        while (size >= 1024 && unitIndex < units.length - 1) {
            size /= 1024;
            unitIndex++;
        }
        
        return `${size.toFixed(2)} ${units[unitIndex]}`;
    }

    getMemoryStats() {
        return this.memoryStats;
    }
}

// 初始化内存监控
const memoryMonitor = new MemoryMonitor();

2. 内存泄漏检测中间件

// 内存泄漏检测中间件
const express = require('express');
const router = express.Router();

class LeakDetector {
    constructor() {
        this.eventListeners = new Map();
        this.timers = new Set();
        this.garbageCollector = null;
    }

    // 检测事件监听器泄漏
    trackEventListeners(eventEmitter, eventName, handler) {
        const key = `${eventEmitter.constructor.name}:${eventName}`;
        if (!this.eventListeners.has(key)) {
            this.eventListeners.set(key, []);
        }
        
        const listeners = this.eventListeners.get(key);
        listeners.push(handler);
        
        // 为该事件添加清理函数
        const originalRemoveListener = eventEmitter.removeListener;
        eventEmitter.removeListener = (name, fn) => {
            const listeners = this.eventListeners.get(key) || [];
            const index = listeners.indexOf(fn);
            if (index > -1) {
                listeners.splice(index, 1);
            }
            return originalRemoveListener.call(eventEmitter, name, fn);
        };
    }

    // 检测定时器泄漏
    trackTimer(timer) {
        this.timers.add(timer);
        return timer;
    }

    // 定期清理未使用的定时器
    startCleanup() {
        this.garbageCollector = setInterval(() => {
            this.cleanupTimers();
            this.reportLeaks();
        }, 30000); // 每30秒检查一次
    }

    cleanupTimers() {
        // 这里可以实现更复杂的清理逻辑
        console.log(`当前定时器数量: ${this.timers.size}`);
    }

    reportLeaks() {
        // 报告潜在的内存泄漏
        if (this.eventListeners.size > 100) {
            console.warn(`检测到大量事件监听器: ${this.eventListeners.size}`);
        }
    }
}

const leakDetector = new LeakDetector();
leakDetector.startCleanup();

// Express中间件示例
router.use('/api', (req, res, next) => {
    // 跟踪请求处理过程中的内存使用
    const startMemory = process.memoryUsage();
    
    res.on('finish', () => {
        const endMemory = process.memoryUsage();
        const memoryDiff = {
            rss: endMemory.rss - startMemory.rss,
            heapUsed: endMemory.heapUsed - startMemory.heapUsed
        };
        
        if (memoryDiff.heapUsed > 1024 * 1024) { // 超过1MB
            console.warn(`请求内存使用异常: ${memoryDiff.heapUsed} bytes`);
        }
    });
    
    next();
});

内存优化最佳实践

1. 流式数据处理

避免一次性加载大量数据到内存中。

// 流式数据处理示例
const fs = require('fs');
const readline = require('readline');

// ❌ 错误：一次性读取大文件
function processLargeFileBad(filename) {
    const data = fs.readFileSync(filename, 'utf8');
    const lines = data.split('\n');
    
    // 处理所有行
    lines.forEach(line => {
        // 处理每一行
        processLine(line);
    });
}

// ✅ 正确：流式处理
function processLargeFileGood(filename) {
    const fileStream = fs.createReadStream(filename, 'utf8');
    const rl = readline.createInterface({
        input: fileStream,
        crlfDelay: Infinity
    });

    rl.on('line', (line) => {
        processLine(line);
    });

    rl.on('close', () => {
        console.log('文件处理完成');
    });
}

function processLine(line) {
    // 处理单行数据
    console.log(`处理行: ${line.substring(0, 50)}...`);
}

2. 对象池模式

重用对象以减少GC压力。

// 对象池实现
class ObjectPool {
    constructor(createFn, resetFn, maxSize = 100) {
        this.createFn = createFn;
        this.resetFn = resetFn;
        this.pool = [];
        this.maxSize = maxSize;
        this.inUse = new Set();
    }

    acquire() {
        let obj;
        
        if (this.pool.length > 0) {
            obj = this.pool.pop();
        } else {
            obj = this.createFn();
        }
        
        this.inUse.add(obj);
        return obj;
    }

    release(obj) {
        if (this.inUse.has(obj)) {
            this.resetFn(obj);
            this.inUse.delete(obj);
            
            if (this.pool.length < this.maxSize) {
                this.pool.push(obj);
            }
        }
    }

    getStats() {
        return {
            poolSize: this.pool.length,
            inUse: this.inUse.size,
            total: this.pool.length + this.inUse.size
        };
    }
}

// 使用示例
const userPool = new ObjectPool(
    () => ({ id: 0, name: '', email: '' }),
    (obj) => {
        obj.id = 0;
        obj.name = '';
        obj.email = '';
    },
    50
);

// 在高并发场景中重用对象
function handleUserRequest(userData) {
    const user = userPool.acquire();
    
    try {
        user.id = userData.id;
        user.name = userData.name;
        user.email = userData.email;
        
        // 处理用户数据
        return processUserData(user);
    } finally {
        userPool.release(user);
    }
}

错误处理机制设计

统一错误处理架构

良好的错误处理机制是高并发系统稳定性的关键。

// 统一错误处理中间件
const express = require('express');
const app = express();

class ErrorHandler {
    constructor() {
        this.errorHandlers = new Map();
        this.setupGlobalErrorHandling();
    }

    setupGlobalErrorHandling() {
        // 全局未捕获异常处理
        process.on('uncaughtException', (error) => {
            console.error('未捕获的异常:', error);
            this.handleCriticalError(error);
        });

        // 全局未处理拒绝的Promise
        process.on('unhandledRejection', (reason, promise) => {
            console.error('未处理的Promise拒绝:', reason, promise);
            this.handleCriticalError(reason);
        });

        // 优雅关闭
        process.on('SIGTERM', () => {
            console.log('收到SIGTERM信号，正在优雅关闭...');
            this.gracefulShutdown();
        });

        process.on('SIGINT', () => {
            console.log('收到SIGINT信号，正在优雅关闭...');
            this.gracefulShutdown();
        });
    }

    handleCriticalError(error) {
        // 记录错误日志
        this.logError(error);
        
        // 发送告警通知
        this.sendAlert(error);
        
        // 如果是致命错误，尝试重启
        if (this.isFatalError(error)) {
            setTimeout(() => {
                process.exit(1);
            }, 1000);
        }
    }

    logError(error) {
        const errorInfo = {
            timestamp: new Date().toISOString(),
            message: error.message,
            stack: error.stack,
            code: error.code,
            level: 'ERROR'
        };
        
        console.error(JSON.stringify(errorInfo));
    }

    sendAlert(error) {
        // 可以集成监控系统发送告警
        console.log('发送告警通知:', error.message);
    }

    isFatalError(error) {
        // 定义致命错误类型
        const fatalErrors = ['ECONNRESET', 'EPIPE', 'ETIMEDOUT'];
        return fatalErrors.includes(error.code) || error.message.includes('fatal');
    }

    gracefulShutdown() {
        // 关闭服务器连接
        // 清理资源
        // 保存状态
        console.log('服务已优雅关闭');
        process.exit(0);
    }

    registerErrorHandler(type, handler) {
        this.errorHandlers.set(type, handler);
    }

    async handleError(error, context = {}) {
        const handler = this.errorHandlers.get(error.type) || this.defaultHandler;
        return await handler(error, context);
    }

    defaultHandler(error, context) {
        return {
            success: false,
            error: error.message,
            context: context,
            timestamp: new Date().toISOString()
        };
    }
}

const errorHandler = new ErrorHandler();

// Express错误处理中间件
app.use((err, req, res, next) => {
    console.error('请求错误:', err);
    
    const response = {
        success: false,
        error: err.message,
        timestamp: new Date().toISOString()
    };
    
    if (process.env.NODE_ENV === 'development') {
        response.stack = err.stack;
    }
    
    res.status(err.status || 500).json(response);
});

// 全局错误处理
app.use((error,

本文来自极简博客，作者：梦境旅人，转载请注明原文链接：Node.js高并发系统架构设计：事件循环优化、集群部署与内存泄漏检测

打赏

本文固定链接: https://www.cxy163.net/archives/9638 | 绝缘体

该日志由 绝缘体.. 于 2017年12月22日 发表在 未分类 分类下， 你可以发表评论，并在保留原文地址及作者的情况下引用到你的网站或博客。
原创文章转载请注明: Node.js高并发系统架构设计：事件循环优化、集群部署与内存泄漏检测 | 绝缘体
关键字: , , , ,
【上一篇】
【下一篇】

您可能还会对这些文章感兴趣！

  1. CVE-2021-35042
  2. golang内存对齐分析(转载)
  3. JQuery 模拟点击事件，自动触发事件
  4. Windows下DOS命令查看占用××端口的程序
  5. MikroTik RouterOS 中的 system history 功能
  6. 避免在Swift中出现Thread 1: EXC_BAD_AC
  7. 苹果电脑mds、mds_stores、mdworker 占用大量 cpu
  8. Node.js高并发服务性能优化实战：从事件循环到集
  9. CentOS6/7 怎么配置守护进程？
  10. 微信小程序点击事件和长按事件
  11. C++中的内存分配错误及解决方法
  12. Objective-C学习笔记：开发iOS应用的必备知识
  13. 解决Invalid Reference”错误的方法
  14. 使用Express构建快速的Node.js后端
  15. Node.js 20重大更新解读：性能提升30%的背后技术
  16. How to Build Scalable and High-Performing

Node.js高并发系统架构设计：事件循环优化、集群部署与内存泄漏检测：等您坐沙发呢！

发表评论


快捷键：Ctrl+Enter