解秘 Node.js 单线程实现高并发请求原理，以及串联同步执行并发请求的方案

class Recorder {
    private list: any[];
    private queueList: any[];
    private intervalTimer;
    constructor() {
        this.list = [];
        this.queueList = [];
        this.intervalTimer = null;
    }
    // 根据 id 获取任务结果
    public get(id: string) {
        let data;
        console.log('this.list: ', this.list);
        let index;
        for (let i = 0; i < this.list.length; i++) {
            const item = this.list[i];
            if (id === item.id) {
                data = item.data;
                index = i;
                break;
            }
        }
        // 删除获取到结果的项
        if (index !== undefined) {
            this.list.splice(index, 1);
        }
        return data;
    }
    public clear() {
        this.list = [];
        this.queueList = [];
    }
    // 添加项
    public async addQueue(item: any) {
        this.queueList.push(item);
    }
    public async runQueue() {
        clearInterval(this.intervalTimer);
        if (!this.queueList.length) {
            // console.log('队列执行完毕');
            return;
        }
        // 取出队列里面的最后一项
        const item = this.queueList.shift();
        console.log('item: ', item);
        // 执行队列的回调
        const data = await item.callback();
        console.log('回调执行完成: ', data);
        // 把结果放进 结果数组
        this.list.push({ id: item.id, data });
    }
    public interval() {
        clearInterval(this.intervalTimer);
        this.intervalTimer = setInterval(async () => {
            clearInterval(this.intervalTimer);
            // 一直执行里面的任务
            await this.runQueue();
            this.interval();
        }, 200);
    }
}
const recorder = new Recorder();
recorder.interval();
export default recorder;

const Koa = require('koa')
const Router = require('koa-router')
const cuid = require('cuid');
const bodyParser = require('koa-bodyparser')
import recorder from "./libs/recorder";
const MAX_WAITING_TIME = 60 * 5; // 最大等待时长
// web服务端口
const SERVER_PORT: number = 3000;
const app = new Koa();
app.use(bodyParser());
const router = new Router();
/**
 * 程序睡眠
 * @param time 毫秒
 */
const timeSleep = (time: number) => {
    return new Promise((resolve) => {
        setTimeout(() => {
            resolve("");
        }, time);
    });
};
/**
 * 程序睡眠
 * @param second 秒
 */
const sleep = (second: number) => {
    return timeSleep(second * 1000);
};
router.post("/getPort", async (ctx, next) => {
    const { num } = ctx.request.body;
    const uniqueId = cuid();
    console.log('uniqueId: ', uniqueId);
    recorder.addQueue({
        id: uniqueId,
        callback: getPortFun(num)
    });
    let waitTime = 0;
    while (!ctx.body) {
        await sleep(0.2);
        console.log('1');
        const data: any = recorder.get(uniqueId);
        if (data) {
            ctx.body = {
                code: 0,
                data: data,
                msg: 'success'
            };
        }
        waitTime++;
        // 超过最大时间就返回一个结果
        if (waitTime > MAX_WAITING_TIME) {
            ctx.body = {};
        }
    }
});
// 返回一个函数
function getPortFun(num) {
    return () => {
        return new Promise((resolve) => {
            // 模拟异步程序
            setTimeout(() => {
                console.log(`num${num}: `, num);
                resolve(num * num);
            }, num * 1000);
        });
    };
}
app.use(router.routes()).use(router.allowedMethods());
app.listen(SERVER_PORT);