来自同步问题node.js

Question

我想要同步结果。
我只想通过将5000除以1来输入数据。
但是，由于异步上市，它正在挣扎。
我想看看像Java这样的同步语言的结果。

我想这些结果：

100-elements 
commit 
100-elements 
commit 
100-elements 
commit 
100-elements 
commit 

但是，代码目前得到以下结果：

100-elements 
100-elements 
100-elements 
100-elements 
100-elements 
. 
. 
. 
. 
100-elements 
commit 
commit 
commit 
commit 
commit 
commit 
commit 
. 
. 
. 
. 
commit 

我怎样才能得到这些结果？请帮帮我。谢谢。

mysql.getConnection(function(err, connection){ 

    if(err){ connection.release(); return; } 

    var array = []; 
    var count = 300000; 
    var length = count; 

    for(var i=0; i<count; i++){ 

    (function(currentI, master){ 
     process.nextTick(function(){ 

     array.push([currentI, master]); 

     if(currentI % 5000 === 0){ 
      console.log('100-elements'); 
      array = []; 

      connection.beginTransaction(function(err){ 
      if(err){ 
       throw err; 
      } 

      var query = "insert into users(username, password) values ?"; 

      connection.query(query, [array], function (err, rows) { 

       if (!err) { 
       //commit start 
       connection.commit(function(){ 
        if (err) { 
        console.error(err); 
        connection.rollback(function() { 
         console.error('rollback error'); 
         throw err; 
        }); 
        } else { 
        console.log("Commit"); 
        }//if err 
        }); //commit end 
       } else { 
            console.log(err); 
       connection.rollback(function(){ 
        throw err; 
       }); 
       } // if 
      }) // cnnection query 
      }); // beginTransaction 
     } //if 

     }); 
    }(i, 'master')); 
    } //for 
}) // getConnection 

Answer 1

您可以在node.js中使用几种设计模式来运行顺序异步操作。在它们中，你不能运行一个紧密的循环等待发生的事情 - 你必须让node.js中的单个Javascript线程运行，并尽可能多地给它一个循环。

手册迭代

把代码在本地功能的迭代（我通常称它为next()），然后当一个反复调用其去年完成的功能，可以再次调用next()开始下一次迭代。您可以通过测试某些条件来完成操作，如果事情已完成，则不要致电next()，或者可以测试第一行next()以查看是否完成。

请参阅下面的代码示例，了解您的代码在手动迭代时的外观。

序列承诺

如果您使用的承诺为您的异步操作，那么你就可以让链式承诺为您做的所有排序为p().then(f1).then(f2).then(f3)。你可以在这个答案中看到一个例子：Promises like async.each。

使用异步模块

的Async module支持许多异步管理功能。许多人认为它非常有用 - 其他人更愿意使用承诺来解决类似的问题。无论如何，它有许多不同的排序功能。例如，如果你想异步遍历数组，你可以使用这样的事情：

async.eachSeries(hugeArray, function iterator(item, callback) { 
    if (inCache(item)) { 
    callback(null, cache[item]); // if many items are cached, you'll overflow 
    } else { 
    doSomeIO(item, callback); 
    } 
}, function done() { 
    //... 
}); 

---

这里有一个版本的代码，做使用自定义next()迭代函数手动迭代。

function runQuery(callback) { 
    mysql.getConnection(function(err, connection) { 
     if (err) { 
      connection.release(); 
      callback(err); 
      return; 
     } 

     var array = []; 
     var count = 10; 
     var index = 0; 

     function next() { 
      if (index++ < count) { 
       array.push([index, 'master']); 
       console.log('100-elements'); 
       connection.beginTransaction(function(err) { 
        if (err) { 
         // can't throw here in an async function 
         // use callback to communicate error 
         callback(err); 
         return; 
        } 

        var query = "insert into users(username, password) values ?"; 
        connection.query(query, [array], function(err, rows) { 

         if (!err) { 
          //commit start 
          connection.commit(function() { 
           if (err) { 
            console.error(err); 
            connection.rollback(function() { 
             console.error('rollback error'); 
             callback(err); 
             return; 
            }); 
           } else { 
            console.log("Commit"); 
            // now do the next iteration 
            next(); 
           } // if err 
          }); //commit end 
         } else { 
          console.log(err); 
          connection.rollback(function() { 
           callback(err); 
           return; 
          }); 
         } // if      
        }); 
       }); 
      } 
     } 
    }); 
}