标签：Axios 请求 pms ts 并发 Promise QPS now

Axios请求并发限制 - 简书 https://www.jianshu.com/p/d3529d18cf59 

0.2352020.07.29 18:41:34字数 845阅读 6,213

标签

NodeJS并发请求，并行请求，QPS限制，Axios并发限制，Axios并发请求

背景

由于调用第三方服务的API的时候，第三方对请求的QPS会有一定的限制，如百度的人脸识别接口，QPS=5，腾讯地图开放平台的普通账号QPS=5，那么在使用的过程中如果每秒请求数超过此限制，接口就会返回报错。导致请求失败。因此，需要在本地实现QPS的控制，当把多个Axios的请求扔到Promise队列中的时候，不会导致请求超限的问题。

众所周知，Promise对象的运行并不是等调用Promise.all()的时候才会执行，而是在创建这个Promise的时候就已经开始执行了，所以从Promise这块去下手显然是无法实现的，需要在扔进Promise[]数组的这些Promise中去实现限制。

更多关于Promise并发等问题请自行学习了解，今天以Axios为例进行展开讨论。

开始

对于一个Axios请求来说返回一个Promise，这个大家都知道的哈~ 正常的Axios请求大概写成这样：

const AXIOS = require('axios')
async function AA() {
    let res = await AXIOS({
        method: 'GET',
        url: 'https://www.baidu.com'
    }).then(res => res.data)
    console.log(res)
}

如果需要100个并发请求，则可以利用Promise.all()来实现：

const AXIOS = require('axios')
async function BB() {
    // 定义一个Promise数组
    let pms = []
    for (let i = 0; i < 100; i++) {
        // 往pms中扔进去AXIOS返回的Promise对象们
        pms.push(AXIOS({
            method: 'GET',
            url: 'https://www.baidu.com'
        }).then(res => res.data).catch(err => console.error(err)))
    }
    // 通过Promise.all等待pms中所有的Promise执行完毕并返回结果给pms数组
    pms = await Promise.all(pms)
    console.log(pms)
}

首先，如上面所说，这个请求的Promise是在创建的时候就已经开始执行了（甚至还没push到pms[]中的时候它就已经在执行请求了）。所以如果百度这边的QPS限制为5，同一秒的前5个请求可能可以成功，但是后面的请求就都会因为并发数超限导致失败。当然，这里最简单的方法就是通过for循环进行限制，让for循环扔进去5个后就睡一会儿，睡到下一秒再继续扔5个就好了。比如像下面这样：

async function CC(QPS = 5) {
    const s = new Date().getTime()
    // 定义一个Promise数组
    let pms = []
    for (let i = 1; i <= 20; i++) {
        // 往pms中扔进去AXIOS返回的Promise对象们
        pms.push(AXIOS({
            method: 'GET',
            url: 'https://www.baidu.com'
        }).then(res => res.data).catch(err => console.error(err)))
        // 如果遇到QPS的倍数就歇1秒
        if (i % QPS == 0) await new Promise(r => setTimeout(() => {
            r()
        }, 1000))
    }
    // 通过Promise.all等待pms中所有的Promise执行完毕并返回结果给pms数组
    pms = await Promise.all(pms)
    console.log(pms)
    console.log('运行耗时：', new Date().getTime() - s)
}

上述方式是可以实现的，但是也有一定的弊端，比如可能涉及到修改的地方比较多，而且像是foreach这种迭代可能还不支持for循环中的sleep，那么今天我们就以Axios的特性来实现。

Axios的并发请求控制

在了解了Axios文档后得知，Axios有一个interceptors的拦截器机制，可以在发送请求前和请求结束返回前进行拦截，通过自定义函数实现消息的处理：【传送门】

那么我们是不是可以通过这个拦截器中实现sleep的方式去进行QPS控制呢？说干咱就干！

首先自定义一个interceptors函数：

let qpsMap = new Map()
const qpsController = (QPS = 5, OFFSET = 50) => async (config) => {
    const now = new Date().getTime()
    let {
        count,
        ts
    } = qpsMap.get(config.url) || {
        count: 1,
        ts: now
    }

    // console.log('Before', config.url, now, ts, count)
    // 对于Math.floor和parseInt来说，据说Math.floor性能更快
    if (Math.floor(now / 1000) <= Math.floor(ts / 1000)) {
        // 如果当前时间 ≤ Map中该接口的ts时间，说明前面已经有超过并发后在等待的请求了
        // 只比较秒，忽略毫秒，因为QPS是以秒为周期计算的，即每秒多少个请求数
        if (count < QPS) {
            // 如果当前url的请求数没有达到QPS的限制，则计数器+1
            count++
        } else {
            // 否则，重置计数器，同时将时间戳设置为当前ts的下一整秒
            // 这里需要将ts设置为当前ts的下一秒，而不是当前时间，因为当前ts可能已经远大于当前时间了
            ts = 1000 * (Math.floor(ts / 1000) + 1)
            count = 1
        }
    } else {
        // 否则：当前时间大于ts，说明已经没有排队的请求了（可能有未完成的，但是都已经请求了）
        // 则将当前ts重置
        ts = now
        count = 1
    }
    qpsMap.set(config.url, {
        count,
        ts
    })
    // console.log('After ', config.url, now, ts, count)

    // 计算休眠时间：
    // 由于本地服务器和远程服务器之间可能存在时间差会发生这种情况：
    // 前5个请求在10:00:00.200时发送过去后，此时本地时间可能到了10:00:00.900到来的第六请求由于超出了QPS=5的限制，会休眠100ms
    // 但是由于本地和服务端时间差的问题，第六个休眠100ms后发送了请求，服务端的时间可能才是10:00:00.950，导致了QPS超限报错
    // 所以，这里添加一个OFFSET偏移值来纠正本地和服务端之间的时间差问题，默认为50ms，若出现QPS超限，请酌情增大此值
    let sleep = ts - now
    sleep = sleep > 0 ? sleep + OFFSET : 0
    // console.log('Sleep Is', sleep)
    // 让当前的请求睡一会儿再请求
    await new Promise(resolve => setTimeout(() => resolve(), sleep))
    // 原封不动返回config，或做一些你自己的处理后返回
    return config
}

然后需要自定义一个AXIOS实例，并设置其request的interceptors为此函数：

async function BaiduClient(url = '', params = {}) {
    // 创建一个instance实例
    let instance = AXIOS.create({
        baseURL: 'http://www.baidu.com',
        timeout: 2000
    })
    // 配置本实例的interceptors为刚才的qpsController
    instance.interceptors.request.use(qpsController())

    return await instance.request({
        url,
        params
    }).then(response => response.status)
}

// 测试并发请求，并尝试优化qpsController(QPS,OFFSET)中的参数值
let pms = []
for(let i=0;i<=10;i++){
    pms.push(BaiduClient().then(res=>console.log(i, res)))
}
Promise.all(pms)

20200812版本更新

经过一段时间的学习，我们知道获取时间的时候通过Performance库效率更高，而且通过位运算进行取整比通过Math库效率高，同时将下一秒的计算由之前的下取整Math.floor改为了上取整Math.ceil，从而解决掉OFFSET问题。所以我们对qpsController函数进行如下改进：

// 引入Performance库来获取当前时间戳
const Performance = require('perf_hooks').performance
let qpsMap = new Map()
const qpsController = (QPS = 5, OFFSET = 0) => async (config) => {
    const now = Math.trunc(Performance.timeOrigin + Performance.now()) // Math.trunc(1597224439841.351)=1597224439841
    let {
        count,
        ts
    } = qpsMap.get(config.url) || {
        count: 1,
        ts: now
    }

    // console.log('Before', config.url, now, ts, (now / 1000) >> 0 <= (ts / 1000) >> 0, count)
    // 通过位运算实现取整，提高效率
    if ((now / 1000) >> 0 <= (ts / 1000) >> 0) {
        // 如果当前时间 ≤ Map中该接口的ts时间，说明前面已经有超过并发后在等待的请求了
        // 只比较秒，忽略毫秒，因为QPS是以秒为周期计算的，即每秒多少个请求数
        if (count < QPS) {
            // 如果当前url的请求数没有达到QPS的限制，则计数器+1
            count++
        } else {
            // 否则，重置计数器，同时将时间戳设置为当前ts的下一整秒
            // 这里需要将ts设置为当前ts的下一秒，而不是当前时间，因为当前ts可能已经远大于当前时间了
            // 这里修改以前的下取整为上取整，从而可以解决OFFSET问题
            ts = 1000 * Math.ceil(ts / 1000 + 1)
            count = 1
        }
    } else {
        // 否则：当前时间大于ts，说明已经没有排队的请求了（可能有未完成的，但是都已经请求了）
        // 则将当前ts重置
        ts = now
        count = 1
    }
    qpsMap.set(config.url, {
        count,
        ts
    })
    // console.log('After ', config.url, now, ts, count)

    // 计算休眠时间：
    // 由于本地服务器和远程服务器之间可能存在时间差会发生这种情况：
    // 前5个请求在10:00:00.200时发送过去后，此时本地时间可能到了10:00:00.900到来的第六请求由于超出了QPS=5的限制，会休眠100ms
    // 但是由于本地和服务端时间差的问题，第六个休眠100ms后发送了请求，服务端的时间可能才是10:00:00.950，导致了QPS超限报错
    // 所以，这里添加一个OFFSET偏移值来纠正本地和服务端之间的时间差问题，默认为0ms，若出现QPS超限，请酌情增大此值
    let sleep = ts - now
    sleep = sleep > 0 ? sleep + OFFSET : 0
    // console.log('Sleep Is', sleep)
    // 让当前的请求睡一会儿再请求
    await new Promise(resolve => setTimeout(() => resolve(), sleep))
    // 原封不动返回config，或做一些你自己的处理后返回
    return config

 

 

标签：Axios,请求,pms,ts,并发,Promise,QPS,now
来源： https://www.cnblogs.com/rsapaper/p/16107359.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。