promise处理并发请求

阳光穿透心脏的1/2处 2022-12-01 01:23 138阅读 0赞

asyncPool=(poolLimit, array, iteratorFn)=> { 
        let i = 0;
        const ret = [];
        const executing = []
        const enqueue = function () { 
            // 边界处理，array为空数组
            if (i === array.length) { 
                return Promise.resolve();
            }
            // 每调一次enqueue，初始化一个promise
            const item = array[i++];
            const p = Promise.resolve().then(() => iteratorFn(item, array));
            // 放入promises数组
            ret.push(p);
            // promise执行完毕，从executing数组中删除
            const e = p.then(() => executing.splice(executing.indexOf(e), 1));
            // 插入executing数字，表示正在执行的promise
            executing.push(e);
            // 使用Promise.rece，每当executing数组中promise数量低于poolLimit，就实例化新的promise并执行
            let r = Promise.resolve();
            if (executing.length >= poolLimit) { 
                r = Promise.race(executing);
            }
            // 递归，直到遍历完array
            return r.then(() => enqueue());
        };
        return enqueue().then(() => Promise.all(ret));
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODk3OTc4_size_16_color_FFFFFF_t_70][]

/** * @params list {Array} - 要迭代的数组 * @params limit {Number} - 并发数量控制数 * @params asyncHandle {Function} - 对`list`的每一个项的处理函数，参数为当前处理项，必须 return 一个Promise来确定是否继续进行迭代 * @return {Promise} - 返回一个 Promise 值来确认所有数据是否迭代完成 */
     
    let mapLimit = (list, limit, asyncHandle) => { 
        let recursion = (arr) => { 
            return asyncHandle(arr.shift())
                .then(()=>{ 
                    if (arr.length!==0) return recursion(arr)   // 数组还未迭代完，递归继续进行迭代
                    else return 'finish';
                })
        };
        
        let listCopy = [].concat(list);
        let asyncList = []; // 正在进行的所有并发异步操作
        while(limit--) { 
            asyncList.push( recursion(listCopy) ); 
        }
        return Promise.all(asyncList);  // 所有并发异步操作都完成后，本次并发控制迭代完成
    }

第三种的方式

//省略代码
    
    // 计数器
    var count = 0;
    // 全局锁
    var lock = [];
    var l = urls.length;
    // 阻塞函数
    function block(){ 
        let _resolve;
        return  new Promise((resolve,reject)=>{ 
            _resolve=resolve;
            // resolve不执行,将其推入lock数组;
            lock.push(_resolve);
        });
    }
    // 叫号机
    function next(){ 
        lock.length&&lock.shift()()
    }
    async function bao(){ 
        if(count>=3){ 
            //超过限制利用await和promise进行阻塞;
            await block();
        }
        if(urls.length>0){ 
            console.log(count);
            count++
            await loadImg(urls.shift());
            count--;
            next()
        }
    }
    for (let i = 0; i < l; i++) { 
        bao();
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODk3OTc4_size_16_color_FFFFFF_t_70]: /images/20221123/75037cb2ade74c09978caf693f7eb7ac.png