微信小程序promise实现并发请求队列

关于promise的一个简单的描述

BLOG

一个 Promise 就是一个代表了 异步操作最终完成或者失败的对象。promise本质上是一个绑定了回调的对象，而不是将回调传进函数内部</br>
通过2个例子来解释一下，promise绑定了回调的对象,将回调传进函数内部</br>
下面是一个比较基础简单的例子

    //传统处理ajax异步处理方式,我们是将
    $.ajax({
        method : 'POST',
        data : {},
        success : function(){
            $.ajax({
                method : '',
                data : {},
                success  : function(){
                    $.ajax()
                }
            })
            ......
        }
    })

    function ajax(){
        return new Promise(function(resolve,reject){
            $.ajax({
                method : 'POST',
                data : {},
                success : function(res){
                    resolve(res)
                }
            })
        })
    }
     // 在每次ajax请求完成后，我们return了一个我们封装的ajax(),而这个ajax()return 了一个promise对象实例，我们通过then()方法,来捕捉这个异步的成功状态resolve。catch()方法reject
    ajax().then(function(res){
        if(res.data.code == 200){}
        ..
        return ajax()
    }).then(function(res){
        if(res.data.code == 200){}
        ........
        return ajax()
    }).then(function(){
        .....
    }).catch(function(){})

promise实现并发请求队列主要是利用了promise的all()方法

Promise.all(iterable) 方法返回一个 Promise 实例，此实例在 iterable 参数内所有的 promise 都“完成（resolved）”或参数中不包含 promise 时回调完成（resolve）；如果参数中 promise 有一个失败（rejected），此实例回调失败（reject），失败原因的是第一个失败 promise 的结果。</br>
promise.all()参数节后接受接收一个iterable，其实就是一个类数组,当这个all内的promise方法全部resolve的时候他本身才会resolve

需求

因为现在做的是一个小程序统计SDK提供给小程序开发者使用，前一段时间我们服务器被恶意攻击导致负载/分发任务层服务器大量的任务堆积。</br>
导致SDK上报超时faill,比较尴尬的是我对上报做了一个重试机制，这个并发量一直在重试，直到重试3次，暂用了微信并发数量影响了开发者小程序响应很慢。</br>

• 雏形

    function Queue(){
        var _this = this;
        this.task = [];
        this.queue = [];
        this.activeCont = 0;
        this.concurrency = 4;
        this.push = function(){}
        this.all = function(){}
        this.next = function(){}
    }

• 补充代码

  if (typeof wx.Queue === "undefined") {
    wx.Queue = new Queue();
    wx.Queue.all();
  }
  // 请求队列
  function Queue() {
    this.concurrency = 4;
    this.queue = [];
    this.tasks = [];
    this.activeCount = 0;
    var _this = this;
    this.push = function (fn) {
      this.tasks.push(new Promise(function (resolve, reject) {
        var task = function () {
          _this.activeCount++;
          fn().then(function (data) {
            resolve(data);
          }).then(function () {
            _this.next();
          });
        };
        if (_this.activeCount < _this.concurrency) {
          task();
        } else {
          _this.queue.push(task);
        }
      }));
    };
    this.all = function () {
      return Promise.all(this.tasks);
    };
    this.next = function () {
      _this.activeCount--;
      if (_this.queue.length > 0) {
        _this.queue.shift()();
      }
    };
  }