blocks|key|3000076|text|这里可能有一个简单的解决方案：http://howtonode.org/control-flow-part-ii滚动到并行操作。另一种方法是让A，B和C都共享相同的回调函数，让该函数有一个全局的或至少是函数外的增量器，如果这三个函数都调用了回调函数，那么让它运行D，当然你也必须将A，B和C的结果存储在某个地方。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3000077|entityMap|0|LINK|mutability|MUTABLE|url|http://howtonode.org/control-flow-part-ii^0|F|15|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

A simple solution might be possible here: <a href="http://howtonode.org/control-flow-part-ii" rel="nofollow">http://howtonode.org/control-flow-part-ii</a> scroll to Parallel actions. Another way would be to have A,B, and C all share the same callback function, have that function have an global or at least out-of-the-function incrementor, if all three have called the callback then let it run D, ofcourse you will have to store the results of A,B, and C somewhere as well.

blocks|key|288895|text|在node.js中没有什么是真正并行的，因为它是单线程的。但是，可以安排多个事件并以您无法预先确定的顺序运行。而像数据库访问这样的一些事情实际上是“并行的”，因为数据库查询本身是在单独的线程中运行的，但在完成后又被重新集成到事件流中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|288896|那么，如何在多个事件处理程序上调度回调呢？这是浏览器端javascript动画中常用的一种技术:使用变量来跟踪完成。|288897|这听起来像是一个黑客，它确实是，而且它听起来可能很混乱，留下一堆全局变量来做跟踪，如果用一种较小的语言就会是这样。但在javascript中，我们可以使用闭包：|288898|function+fork+(async_calls,+shared_callback)+{
++var+counter+=+async_calls.length;
++var+callback+=+function+()+{
++++counter+--;
++++if+(counter+==+0)+{
++++++shared_callback()
++++}
++}

++for+(var+i=0;i<async_calls.length;i%2B%2B)+{
++++async_calls[i](callback);
++}
}

//+usage:
fork([A,B,C],D);|code-block|syntax|javascript|288899|在上面的示例中，我们通过假设异步和回调函数不需要参数来保持代码的简单性。当然，您可以修改代码以将参数传递给异步函数，并让回调函数累积结果并将其传递给shared_callback函数。|288900|288901|其他答案：|288902|实际上，即使是这样，fork()函数已经可以使用闭包将参数传递给异步函数：|offset|length|style|CODE|288903|fork([
++function(callback){+A(1,2,callback)+},
++function(callback){+B(1,callback)+},
++function(callback){+C(1,2,callback)+}
],D);|288904|剩下的唯一要做的事情就是将A、B、C的结果累加，并将它们传递给D。|288905|288906|更多额外的答案：|288907|我无法抗拒。吃早餐的时候一直在想这个问题。下面是一个累积结果的fork()实现(通常作为参数传递给回调函数)：|288908|function+fork+(async_calls,+shared_callback)+{
++var+counter+=+async_calls.length;
++var+all_results+=+[];
++function+makeCallback+(index)+{
++++return+function+()+{
++++++counter+--;
++++++var+results+=+[];
++++++//+we+use+the+arguments+object+here+because+some+callbacks+
++++++//+in+Node+pass+in+multiple+arguments+as+result.
++++++for+(var+i=0;i<arguments.length;i%2B%2B)+{
++++++++results.push(arguments[i]);
++++++}
++++++all_results[index]+=+results;
++++++if+(counter+==+0)+{
++++++++shared_callback(all_results);
++++++}
++++}
++}

++for+(var+i=0;i<async_calls.length;i%2B%2B)+{
++++async_calls[i](makeCallback(i));
++}
}|288909|这已经很简单了。这使得fork()具有相当的通用性，并可用于同步多个非同构事件。|288910|Node.js中的用法示例：|288911|//+Read+3+files+in+parallel+and+process+them+together:

function+A+(c){+fs.readFile('file1',c)+};
function+B+(c){+fs.readFile('file2',c)+};
function+C+(c){+fs.readFile('file3',c)+};
function+D+(result)+{
++file1data+=+result[0][1];
++file2data+=+result[1][1];
++file3data+=+result[2][1];

++//+process+the+files+together+here
}

fork([A,B,C],D);|288912|288913|更新|288914|这段代码是在诸如async.js或各种基于promise的库出现之前编写的。我愿意相信async.js是受此启发的，但我没有任何证据。不管怎样..。如果你现在就打算这么做，可以看看async.js或promises。只需考虑上面的答案，就可以很好地解释/说明像async.parallel这样的东西是如何工作的。|288915|为了完整起见，下面是如何使用async.parallel完成此操作的|288916|var+async+=+require('async');

async.parallel([A,B,C],D);|288917|请注意，async.parallel的工作方式与我们上面实现的fork函数完全相同。主要区别在于，根据node.js约定，它将错误作为第一个参数传递给D，并将回调作为第二个参数传递。|288918|使用promises，我们可以这样写：|288919|//+Assuming+A,+B+&+C+return+a+promise+instead+of+accepting+a+callback

Promise.all([A,B,C]).then(D);|288920|entityMap^0|0|0|0|0|0|0|0|A|6|0|0|0|0|0|V|6|0|0|B|6|0|0|0|0|0|0|E|E|0|0|4|E|V|4|23|1|0|0|0^^$0|@$1|2|3|4|5|6|7|1T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1U|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1V|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|1W|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|1X|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|20|8|@$R|21|S|22|T|U]]|9|@]|A|$]]|$1|V|3|W|5|H|7|23|8|@]|9|@]|A|$I|J]]|$1|X|3|Y|5|6|7|24|8|@]|9|@]|A|$]]|$1|Z|3|-4|5|6|7|25|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|26|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|27|8|@$R|28|S|29|T|U]]|9|@]|A|$]]|$1|14|3|15|5|H|7|2A|8|@]|9|@]|A|$I|J]]|$1|16|3|17|5|6|7|2B|8|@$R|2C|S|2D|T|U]]|9|@]|A|$]]|$1|18|3|19|5|6|7|2E|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|H|7|2F|8|@]|9|@]|A|$I|J]]|$1|1C|3|-4|5|6|7|2G|8|@]|9|@]|A|$]]|$1|1D|3|1E|5|6|7|2H|8|@]|9|@]|A|$]]|$1|1F|3|1G|5|6|7|2I|8|@]|9|@]|A|$]]|$1|1H|3|1I|5|6|7|2J|8|@$R|2K|S|2L|T|U]]|9|@]|A|$]]|$1|1J|3|1K|5|H|7|2M|8|@]|9|@]|A|$I|J]]|$1|1L|3|1M|5|6|7|2N|8|@$R|2O|S|2P|T|U]|$R|2Q|S|2R|T|U]|$R|2S|S|2T|T|U]]|9|@]|A|$]]|$1|1N|3|1O|5|6|7|2U|8|@]|9|@]|A|$]]|$1|1P|3|1Q|5|H|7|2V|8|@]|9|@]|A|$I|J]]|$1|1R|3|-4|5|6|7|2W|8|@]|9|@]|A|$]]]|1S|$]]

Nothing is truly parallel in node.js since it is single threaded. However, multiple events can be scheduled and run in a sequence you can't determine beforehand. And some things like database access are actually "parallel" in that the database queries themselves are run in separate threads but are re-integrated into the event stream when completed.

So, how do you schedule a callback on multiple event handlers? Well, this is one common technique used in animations in browser side javascript: use a variable to track the completion.

This sounds like a hack and it is, and it sounds potentially messy leaving a bunch of global variables around doing the tracking and in a lesser language it would be. But in javascript we can use closures:

<pre><code>function fork (async_calls, shared_callback) {
 var counter = async_calls.length;
 var callback = function () {
 counter --;
 if (counter == 0) {
 shared_callback()
 }
 }

 for (var i=0;i&lt;async_calls.length;i++) {
 async_calls[i](callback);
 }
}

// usage:
fork([A,B,C],D);
</code></pre>

In the example above we keep the code simple by assuming the async and callback functions require no arguments. You can of course modify the code to pass arguments to the async functions and have the callback function accumulate results and pass it to the shared_callback function.

<hr>

<h2>Additional answer:</h2>

Actually, even as is, that <code>fork()</code> function can already pass arguments to the async functions using a closure:

<pre><code>fork([
 function(callback){ A(1,2,callback) },
 function(callback){ B(1,callback) },
 function(callback){ C(1,2,callback) }
],D);
</code></pre>

the only thing left to do is to accumulate the results from A,B,C and pass them on to D.

<hr>

<h2>Even more additional answer:</h2>

I couldn't resist. Kept thinking about this during breakfast. Here's an implementation of <code>fork()</code> that accumulates results (usually passed as arguments to the callback function):

<pre><code>function fork (async_calls, shared_callback) {
 var counter = async_calls.length;
 var all_results = [];
 function makeCallback (index) {
 return function () {
 counter --;
 var results = [];
 // we use the arguments object here because some callbacks 
 // in Node pass in multiple arguments as result.
 for (var i=0;i&lt;arguments.length;i++) {
 results.push(arguments[i]);
 }
 all_results[index] = results;
 if (counter == 0) {
 shared_callback(all_results);
 }
 }
 }

 for (var i=0;i&lt;async_calls.length;i++) {
 async_calls[i](makeCallback(i));
 }
}
</code></pre>

That was easy enough. This makes <code>fork()</code> fairly general purpose and can be used to synchronize multiple non-homogeneous events.

Example usage in Node.js:

<pre><code>// Read 3 files in parallel and process them together:

function A (c){ fs.readFile('file1',c) };
function B (c){ fs.readFile('file2',c) };
function C (c){ fs.readFile('file3',c) };
function D (result) {
 file1data = result[0][1];
 file2data = result[1][1];
 file3data = result[2][1];

 // process the files together here
}

fork([A,B,C],D);
</code></pre>

<hr>

<h2>Update</h2>

This code was written before the existence of libraries like async.js or the various promise based libraries. I'd like to believe that async.js was inspired by this but I don't have any proof of it. Anyway.. if you're thinking of doing this today take a look at async.js or promises. Just consider the answer above a good explanation/illustration of how things like async.parallel work.

For completeness sake the following is how you'd do it with <code>async.parallel</code>:

<pre><code>var async = require('async');

async.parallel([A,B,C],D);
</code></pre>

Note that <code>async.parallel</code> works exactly the same as the <code>fork</code> function we implemented above. The main difference is it passes an error as the first argument to <code>D</code> and the callback as the second argument as per node.js convention.

Using promises, we'd write it as follows:

<pre><code>// Assuming A, B &amp; C return a promise instead of accepting a callback

Promise.all([A,B,C]).then(D);
</code></pre>

blocks|key|288922|text|另一个选项可以是Node的Step模块：https://github.com/creationix/step|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|288923|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/creationix/step^0|K|Y|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Another option could be the Step module for Node: <a href="https://github.com/creationix/step" rel="nofollow">https://github.com/creationix/step</a>

blocks|key|283312|text|我相信"async“模块现在提供了这种并行功能，并且与上面的fork函数大致相同。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|283313|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I believe that now the "async" module provides this parallel functionality and is roughly the same as the fork function above.

blocks|key|3213451|text|futures模块有一个名为join的子模块，我想使用它：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3213452|3213453|将异步调用连接在一起，类似于pthread_join对线程的工作方式。|blockquote|style|CODE|3213454|3213455|3213456|自述文件展示了一些使用freestyle或使用Promise模式的future子模块的很好的例子。文档中的示例：|3213457|var+Join+=+require('join')
++,+join+=+Join()
++,+callbackA+=+join.add()
++,+callbackB+=+join.add()
++,+callbackC+=+join.add();

function+abcComplete(aArgs,+bArgs,+cArgs)+{
++console.log(aArgs[1]+%2B+bArgs[1]+%2B+cArgs[1]);
}

setTimeout(function+()+{
++callbackA(null,+'Hello');
},+300);

setTimeout(function+()+{
++callbackB(null,+'World');
},+500);

setTimeout(function+()+{
++callbackC(null,+'!');
},+400);

//+this+must+be+called+after+all+
join.when(abcComplete);|code-block|syntax|javascript|3213458|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/coolaj86/futures|1|https://github.com/coolaj86/futures/tree/v2.0/join|2|https://github.com/coolaj86/futures/tree/v2.0/future^0|0|7|0|E|4|1|0|0|E|C|0|0|0|X|6|2|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@$A|15|B|16|1|17]|$A|18|B|19|1|1A]]|C|$]]|$1|D|3|-4|5|6|7|1B|8|@]|9|@]|C|$]]|$1|E|3|F|5|G|7|1C|8|@$A|1D|B|1E|H|I]]|9|@]|C|$]]|$1|J|3|-4|5|6|7|1F|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|1G|8|@]|9|@]|C|$]]|$1|L|3|M|5|6|7|1H|8|@]|9|@$A|1I|B|1J|1|1K]]|C|$]]|$1|N|3|O|5|P|7|1L|8|@]|9|@]|C|$Q|R]]|$1|S|3|-4|5|6|7|1M|8|@]|9|@]|C|$]]]|T|$U|$5|V|W|X|C|$Y|Z]]|10|$5|V|W|X|C|$Y|11]]|12|$5|V|W|X|C|$Y|13]]]]

The <a href="https://github.com/coolaj86/futures" rel="noreferrer">futures</a> module has a submodule called <a href="https://github.com/coolaj86/futures/tree/v2.0/join" rel="noreferrer">join</a> that I have liked to use:

<blockquote>
 Joins asynchronous calls together similar to how <code>pthread_join</code> works for threads.
</blockquote>

The readme shows some good examples of using it freestyle or using the <a href="https://github.com/coolaj86/futures/tree/v2.0/future" rel="noreferrer">future</a> submodule using the Promise pattern. Example from the docs:

<pre><code>var Join = require('join')
 , join = Join()
 , callbackA = join.add()
 , callbackB = join.add()
 , callbackC = join.add();

function abcComplete(aArgs, bArgs, cArgs) {
 console.log(aArgs[1] + bArgs[1] + cArgs[1]);
}

setTimeout(function () {
 callbackA(null, 'Hello');
}, 300);

setTimeout(function () {
 callbackB(null, 'World');
}, 500);

setTimeout(function () {
 callbackC(null, '!');
}, 400);

// this must be called after all 
join.when(abcComplete);
</code></pre>

blocks|key|3213464|text|您可能想尝试一下这个小型库：https://www.npmjs.com/package/parallel-io|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3213465|entityMap|0|LINK|mutability|MUTABLE|url|https://www.npmjs.com/package/parallel-io^0|E|15|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

You may want to try this tiny library: <a href="https://www.npmjs.com/package/parallel-io" rel="nofollow">https://www.npmjs.com/package/parallel-io</a>

blocks|key|3213477|text|除了流行的promises和异步库之外，还有第三种优雅的方式--使用“连接”：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3213478|var+l+=+new+Wire();

funcA(l.branch('post'));
funcB(l.branch('comments'));
funcC(l.branch('links'));

l.success(function(results)+{
+++//+result+will+be+object+with+results:
+++//+{+post:+...,+comments:+...,+links:+...}
});|code-block|syntax|javascript|3213479|https://github.com/garmoshka-mo/mo-wire|offset|length|3213480|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|13|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|T|8|@]|9|@$I|U|J|V|1|W]]|A|$]]|$1|K|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|H]]]]

In addition to popular promises and async-library, there is 3rd elegant way - using "wiring":

<pre><code>var l = new Wire();

funcA(l.branch('post'));
funcB(l.branch('comments'));
funcC(l.branch('links'));

l.success(function(results) {
 // result will be object with results:
 // { post: ..., comments: ..., links: ...}
});
</code></pre>

<a href="https://github.com/garmoshka-mo/mo-wire" rel="nofollow">https://github.com/garmoshka-mo/mo-wire</a>

The event-driven programming model of node.js makes it somewhat tricky to coordinate the program flow.

Simple sequential execution gets turned into nested callbacks, which is easy enough (though a bit convoluted to write down). 

But how about parallel execution? Say you have three tasks A,B,C that can run in parallel and when they are done, you want to send their results to task D.

With a fork/join model this would be

<ul>
<li>fork A</li>
<li>fork B</li>
<li>fork C</li>
<li>join A,B,C, run D</li>
</ul>

How do I write that in node.js ? Are there any best practices or cookbooks? Do I have to <a href="https://stackoverflow.com/questions/4496403/extjs-two-parallel-ajax-call">hand-roll a solution</a> every time, or is there some library with helpers for this?

Coordinating parallel execution in node.js

数据库

node.js的事件驱动编程模型使得协调程序流变得有些棘手。简单的顺序执行被转换为嵌套回调，这很容易(尽管写起来有点复杂)。但是并行执行呢？假设您有三个可以并行运行的任务A、B、C，当它们完成后，您希望将它们的结果发送到任务D。对于fork/join模型，这将是fork Afork Bfork Cjoin A，B，C，...

问在node.js中协调并行执行
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在node.js中协调并行执行EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在node.js中协调并行执行
EN