1
function get (i) {
2
  console.log('In ', i)
3
  return new Promise((resolve, reject) => {
4
    setTimeout(() => {
5
      resolve(i * 1000)
6
      console.log('Out', i, 'Out')
7
    }, i * 1000)
8
  })
9
}
10

11
const list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

1
// 并发数量计数
2
let count = 0
3
function run () {
4
  if (count < 3 && list.length) {
5
    count+=1
6
    get(list.shift()).then(() => {
7
      count-=1
8
      run()
9
    })
10
  }
11
}
12

13
// 限定三个并发数量
14
run()
15
run()
16
run()

1
Promise.map(
2
    Iterable<any>|Promise<Iterable<any>> input,
3
    function(any item, int index, int length) mapper,
4
    [Object {concurrency: int=Infinity} options]
5
) -> Promise

1
class Limit {
2
  constructor (n) {
3
    this.limit = n
4
    this.count = 0
5
    this.queue = []
6
  }
7

8
  enqueue (fn) {
9
    // 关键代码: fn, resolve, reject 统一管理
10
    return new Promise((resolve, reject) => {
11
      this.queue.push({ fn, resolve, reject })
12
    })
13
  }
14

15
  dequeue () {
16
    if (this.count < this.limit && this.queue.length) {
17
      // 等到 Promise 计数器小于阈值时，则出队执行
18
      const { fn, resolve, reject } = this.queue.shift()
19
      this.run(fn).then(resolve).catch(reject)
20
    }
21
  }
22

23
  // async/await 简化错误处理
24
  async run (fn) {
25
    this.count++
26
    // 维护一个计数器
27
    const value = await fn()
28
    this.count--
29
    // 执行完，看看队列有东西没
30
    this.dequeue()
31
    return value
32
  }
33

34
  build (fn) {
35
    if (this.count < this.limit) {
36
      // 如果没有到达阈值，直接执行
37
      return this.run(fn)
38
    } else {
39
      // 如果超出阈值，则先扔到队列中，等待有空闲时执行
40
      return this.enqueue(fn)
41
    }
42
  }
43
}
44

45
Promise.map = function (list, fn, { concurrency }) {
46
  const limit = new Limit(concurrency)
47
  return Promise.all(list.map((...args) => {
48
    return limit.build(() => fn(...args))
49
  }))
50
}