如何模拟事件循环中的高负载场景？

while

// 示例：模拟CPU密集型任务
function simulateCpuIntensiveTask(iterations) {
    let result = 0;
    for (let i = 0; i < iterations; i++) {
        // 模拟复杂计算，比如计算平方根、三角函数等
        result += Math.sqrt(i) * Math.sin(i);
    }
    return result;
}

// 在某个HTTP请求处理函数中调用
// app.get('/heavy-sync', (req, res) => {
//     console.log('开始处理重型同步请求...');
//     const start = Date.now();
//     simulateCpuIntensiveTask(100000000); // 1亿次迭代，会阻塞很久
//     const end = Date.now();
//     console.log(`重型同步请求处理完成，耗时：${end - start}ms`);
//     res.send('同步任务完成！');
// });

async/await

then

catch

async/await

// 示例：通过Promise链模拟微任务高负载
function createHeavyPromiseChain(count) {
    let p = Promise.resolve();
    for (let i = 0; i < count; i++) {
        p = p.then(() => {
            // 在每个Promise的then回调中执行少量计算
            let temp = 0;
            for (let j = 0; j < 1000; j++) { // 每次计算1000次
                temp += Math.random();
            }
            return temp;
        });
    }
    return p;
}

// app.get('/heavy-microtask', async (req, res) => {
//     console.log('开始处理微任务高负载请求...');
//     const start = Date.now();
//     await createHeavyPromiseChain(10000); // 1万个Promise链，每个都有计算
//     const end = Date.now();
//     console.log(`微任务高负载请求处理完成，耗时：${end - start}ms`);
//     res.send('微任务任务完成！');
// });

queueMicrotask

setTimeout

setImmediate

// 示例：大量setImmediate回调，每个回调都有耗时操作
// app.get('/heavy-immediate', (req, res) => {
//     console.log('开始处理大量setImmediate请求...');
//     const count = 10000; // 1万个setImmediate
//     let completed = 0;
//     const start = Date.now();

//     for (let i = 0; i < count; i++) {
//         setImmediate(() => {
//             // 每个回调里做一些耗时计算
//             let temp = 0;
//             for (let j = 0; j < 500; j++) {
//                 temp += Math.random();
//             }
//             completed++;
//             if (completed === count) {
//                 const end = Date.now();
//                 console.log(`大量setImmediate请求处理完成，耗时：${end - start}ms`);
//                 res.send('大量立即任务完成！');
//             }
//         });
//     }
// });

perf_hooks

performance.now()

PerformanceObserver

const { performance, PerformanceObserver } = require('perf_hooks');

// 标记开始
performance.mark('startHeavyTask');

// 执行你的高负载代码
simulateCpuIntensiveTask(50000000);

// 标记结束
performance.mark('endHeavyTask');

// 测量两个标记之间的时间
performance.measure('heavyTaskDuration', 'startHeavyTask', 'endHeavyTask');

// 监听并打印测量结果
const obs = new PerformanceObserver((items) => {
    items.getEntries().forEach((entry) => {
        console.log(`${entry.name}: ${entry.duration}ms`);
    });
    obs.disconnect(); // 测量完成后断开观察者
});
obs.observe({ entryTypes: ['measure'] });

--inspect

chrome://inspect

clinic.js

clinic doctor

clinic flame

setImmediate

setTimeout(..., 0)

// 示例：将重型计算分块处理
function chunkedCpuIntensiveTask(iterations, chunkSize, callback) {
    let currentIteration = 0;
    let result = 0;

    function processChunk() {
        const endIteration = Math.min(currentIteration + chunkSize, iterations);
        for (let i = currentIteration; i < endIteration; i++) {
            result += Math.sqrt(i) * Math.sin(i);
        }
        currentIteration = endIteration;

        if (currentIteration < iterations) {
            setImmediate(processChunk); // 继续处理下一块
        } else {
            callback(result); // 所有块处理完毕
        }
    }
    setImmediate(processChunk); // 启动第一个块
}

// app.get('/chunked-task', (req, res) => {
//     console.log('开始处理分块任务...');
//     const start = Date.now();
//     chunkedCpuIntensiveTask(100000000, 100000, (finalResult) => { // 每次处理10万次
//         const end = Date.now();
//         console.log(`分块任务处理完成，耗时：${end - start}ms，结果：${finalResult}`);
//         res.send('分块任务完成！');
//     });
// });

worker_threads

// worker.js (工作线程文件)
const { parentPort } = require('worker_threads');

parentPort.on('message', (message) => {
    if (message.type === 'startHeavyTask') {
        let result = 0;
        for (let i = 0; i < message.iterations; i++) {
            result += Math.sqrt(i) * Math.sin(i);
        }
        parentPort.postMessage({ type: 'taskComplete', result: result });
    }
});

// main.js (主线程文件)
const { Worker } = require('worker_threads');

// app.get('/worker-task', (req, res) => {
//     console.log('开始通过Worker处理任务...');
//     const start = Date.now();
//     const worker = new Worker('./worker.js');

//     worker.postMessage({ type: 'startHeavyTask', iterations: 100000000 });

//     worker.on('message', (msg) => {
//         if (msg.type === 'taskComplete') {
//             const end = Date.now();
//             console.log(`Worker任务处理完成，耗时：${end - start}ms，结果：${msg.result}`);
//             res.send('Worker任务完成！');
//             worker.terminate(); // 任务完成后终止Worker
//         }
//     });

//     worker.on('error', (err) => {
//         console.error('Worker error:', err);
//         res.status(500).send('Worker处理失败！');
//     });

//     worker.on('exit', (code) => {
//         if (code !== 0) {
//             console.error(`Worker exited with code ${code}`);
//         }
//     });
// });

Map

LRU