搞个大函数处理异步问题

function concurrencyRequest () {
    const tasks = []
    const result = []
    let idx = 0,count = 0

    function _start (limit) {
        return new Promise(resolve => {
            async function _handler () {
                if(tasks.length === 0) {
                    resolve([])
                    return 
                }
                const i = idx
                idx++
                const res = await tasks[i]
                result[i] = res
                count++
                
                if(idx < tasks.length) {
                    _handler()
                }                
                if(count === tasks.length) {
                    resolve(result)
                }
            }
            const len = Math.min(tasks.length, limit)
            for(let i = 0 ; i < len; i ++) {
                _handler()
            }    
        })
    }

    function _addTasks (arg) {
        const isPromise = arg instanceof Promise 
        if(isPromise) {
            tasks.push(arg)
            return _addTasks
        } else {
            return _start(arg)
        }
    }
    return _addTasks
}

const request1 = new Promise(resolve => {
    setTimeout(() => {
        resolve(2)
    }, 100);
})
const request2 = new Promise(resolve => {
    setTimeout(() => {
        resolve(4)
    }, 20000);
})

const request3 = new Promise(resolve => {
    setTimeout(() => {
        resolve(1)
    }, 50);
})

const request4 = new Promise(resolve => {
    setTimeout(() => {
        resolve(8)
    }, 3 * 1000);
})

const requestt = concurrencyRequest()

requestt(request1)
requestt(request2)
requestt(request3)
requestt(request4)

requestt(3).then(res => {
    console.log(res);
})