javascript - Node.js:与速度较慢的第三方合作

Question

我使用 Node.js 已经有 5 年了，并且使用这个框架的大型项目也有 2 年了。两年来，我面临着一个问题:如何与堆栈请求的非异步第三方应用程序(例如 MySQL、MongoDB 或 Apache SolR)异步且更快地工作？

我习惯于使用 Promise 并准备多个 Promise 请求，如下所示:

const promises = []

for (let i = 0; i < 1000; i += 1) {
  const promise = mySqlRequest()
  promises.push(promise)
}

Promise.all(promises)
.then()
.catch()

这个例子可以工作，但是会同时向 MySQL 服务器发送 1000 个请求，MySQL 服务器会堆积这些请求并变得非常慢，会消耗大量 RAM。

最好的解决方案是只执行一个大请求，但在某些情况下这是不可能的，我被迫使用递归函数，归根结底是同步的并且速度较慢。

那么，使用 Node.js 和第三方堆栈快速异步工作的最佳方式是什么？

Answer 1

如果一次发送所有请求不起作用，并且逐一发送它们也不起作用，那么您需要类似于线程池的东西，其中可以同时执行任意数量的任务。使用 Promise 可以轻松实现这一点，例如:

Promise.pooled = function(arr, num = 5) {
    return new Promise(function(resolve, reject) {
        var i = -1;
        var error = false;

        var end = function() {
            num--;
            if(num === 0) resolve();
        }

        var next = function() {
            if(error) return;
            i++;
            if(i >= arr.length)
                end();
            else
                arr[i]().then(next).catch(onerr);
        }

        var onerr = function() {
            if(error) return
            error = true
            reject.call(arguments)
        }

        for(var j = 0; j < num; j++)
            next()
    });
}

这允许您传递一个函数数组作为第一个参数，这些函数应该不带参数并返回一个 promise 。然后它将同时执行num。如果其中一个 promise 失败，它自己的 promise 也会失败并停止执行(这很容易改变)。

示例:

Promise.after = function(ms) {
    return new Promise(function(resolve) {
        setTimeout(resolve, ms)
    });
}

Promise.pooled = function(arr, num = 5) {
	return new Promise(function(resolve, reject) {
		var i = -1;
		var error = false;
		
		var end = function() {
			num--;
			if(num === 0) resolve();
		}
		
		var next = function() {
			if(error) return;
			i++;
			if(i >= arr.length)
				end();
			else
				arr[i]().then(next).catch(onerr);
		}
		
		var onerr = function() {
			if(error) return
			error = true
			reject.call(arguments)
		}
		
		for(var j = 0; j < num; j++)
			next()
	});
}

var test = [
	afterH(1000),
	afterH(500),
	afterH(800),
	afterH(600),
	afterH(3000),
	afterH(300),
	afterH(900),
	afterH(2000),
	afterH(1500),
	afterH(900),
	afterH(700),
	afterH(600),
	afterH(700)
];

// helper function, returns a function which when invoked returns a promise
function afterH(ms) {
	return function() {
		console.log("Starting one job")
		return Promise.after(ms);
	}
}

Promise.pooled(test, 3).then(function() {console.log("All jobs finished") }).catch(function() {console.log("Job failed")})