MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Node.js异步编程模型全面解读

2023-12-032.6k 阅读

Node.js异步编程模型基础概念

在Node.js的世界里，异步编程是其核心特性之一。Node.js基于Chrome V8引擎构建，其设计初衷就是为了能够高效地处理I/O密集型任务，而异步编程模型则是实现这一目标的关键。

JavaScript本身是单线程的，在浏览器环境中，这意味着同一时间只能执行一个任务。如果一个任务执行时间过长，就会导致页面卡顿，用户体验变差。在Node.js中同样如此，如果所有操作都是同步执行，那么当进行诸如文件读取、网络请求等I/O操作时，线程会被阻塞，无法处理其他请求，这显然不符合Node.js处理高并发的设计理念。

回调函数（Callback）

回调函数是Node.js异步编程中最基础的方式。简单来说，回调函数就是将一个函数作为参数传递给另一个函数，当异步操作完成时，被调用的函数（即回调函数）会被执行。

以下是一个简单的文件读取示例：

const fs = require('fs');

fs.readFile('example.txt', 'utf8', (err, data) => {
    if (err) {
        console.error('读取文件出错:', err);
        return;
    }
    console.log('文件内容:', data);
});

在上述代码中，fs.readFile是一个异步操作，它接收三个参数：文件名、编码格式以及回调函数。当文件读取操作完成后，会调用回调函数，并将可能出现的错误err和读取到的数据data作为参数传递给回调函数。我们在回调函数中首先检查err，如果有错误则处理错误，否则处理读取到的数据。

回调函数虽然简单直接，但当异步操作嵌套过多时，就会出现“回调地狱”（Callback Hell）的问题。例如：

fs.readFile('file1.txt', 'utf8', (err1, data1) => {
    if (err1) {
        console.error('读取file1.txt出错:', err1);
        return;
    }
    fs.readFile('file2.txt', 'utf8', (err2, data2) => {
        if (err2) {
            console.error('读取file2.txt出错:', err2);
            return;
        }
        fs.readFile('file3.txt', 'utf8', (err3, data3) => {
            if (err3) {
                console.error('读取file3.txt出错:', err3);
                return;
            }
            console.log('依次读取完三个文件的数据');
        });
    });
});

可以看到，随着异步操作的增多，代码变得越来越难以阅读和维护，层层嵌套的回调函数使得代码的逻辑结构变得复杂，这就是回调地狱的典型表现。

事件发射器（Event Emitter）

Node.js中的EventEmitter模块提供了一种基于事件驱动的异步编程方式。EventEmitter类是Node.js核心模块中许多对象的基础，例如fs.ReadStream、net.Socket等。

一个EventEmitter实例可以触发和监听事件。当特定事件发生时，注册的监听器函数会被调用。以下是一个简单的EventEmitter示例：

const EventEmitter = require('events');
const emitter = new EventEmitter();

emitter.on('customEvent', (message) => {
    console.log('接收到自定义事件:', message);
});

setTimeout(() => {
    emitter.emit('customEvent', '这是一条来自定时器的消息');
}, 2000);

在上述代码中，我们首先创建了一个EventEmitter实例emitter，然后使用on方法为customEvent事件注册了一个监听器函数。接着，通过setTimeout模拟一个异步操作，2秒后触发customEvent事件，并传递一条消息。当事件触发时，监听器函数会被调用并输出相应的信息。

EventEmitter在处理复杂的异步流程控制时非常有用，它使得代码的结构更加清晰，各个模块之间的耦合度降低。例如，在一个网络服务器应用中，net.Server实例可以通过EventEmitter来处理连接建立、数据接收、连接关闭等各种事件，开发者可以分别为这些事件注册监听器，而不需要像回调函数那样将所有逻辑都嵌套在一起。

Promise

为了解决回调地狱的问题，Promise应运而生。Promise是一个表示异步操作最终完成（或失败）及其结果值的对象。它有三种状态：pending（进行中）、fulfilled（已成功）和rejected（已失败）。一旦Promise的状态从pending变为fulfilled或rejected，就不会再改变。

创建Promise

我们可以使用new Promise()来创建一个Promise实例，构造函数接收一个执行器函数，该执行器函数接收resolve和reject两个参数。resolve用于将Promise的状态从pending变为fulfilled，并传递成功的值；reject用于将Promise的状态从pending变为rejected，并传递失败的原因。

以下是一个简单的Promise示例，模拟一个异步的延迟操作：

function delay(ms) {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve('延迟操作完成');
        }, ms);
    });
}

delay(2000).then((result) => {
    console.log(result);
}).catch((error) => {
    console.error('操作失败:', error);
});

在上述代码中，delay函数返回一个Promise，通过setTimeout模拟了一个延迟2秒的异步操作，2秒后调用resolve并传递成功的消息。然后我们使用.then()方法来处理Promise成功的情况，.catch()方法来处理Promise失败的情况。

Promise链式调用

Promise的一个强大之处在于它支持链式调用，这使得我们可以将多个异步操作连接起来，而不会出现回调地狱的问题。例如，我们可以将前面的文件读取操作使用Promise改写：

const fs = require('fs');
const util = require('util');

const readFilePromise = util.promisify(fs.readFile);

readFilePromise('file1.txt', 'utf8')
   .then((data1) => {
        console.log('file1.txt内容:', data1);
        return readFilePromise('file2.txt', 'utf8');
    })
   .then((data2) => {
        console.log('file2.txt内容:', data2);
        return readFilePromise('file3.txt', 'utf8');
    })
   .then((data3) => {
        console.log('file3.txt内容:', data3);
    })
   .catch((err) => {
        console.error('读取文件出错:', err);
    });

在上述代码中，我们首先使用util.promisify将fs.readFile这个基于回调的异步函数转换为返回Promise的函数。然后通过链式调用.then()方法依次读取三个文件，每个.then()方法在成功读取一个文件后返回下一个文件读取的Promise，这样代码结构更加清晰，避免了回调地狱。

Promise.all

Promise.all方法用于将多个Promise实例包装成一个新的Promise实例。新的Promise实例在所有传入的Promise都变为fulfilled状态时才会变为fulfilled，并将所有Promise的成功结果组成一个数组作为新Promise的成功值。如果其中任何一个Promise变为rejected状态，新的Promise就会立即变为rejected状态，并将第一个变为rejected的Promise的失败原因作为新Promise的失败原因。

以下是一个使用Promise.all同时读取多个文件的示例：

const fs = require('fs');
const util = require('util');

const readFilePromise = util.promisify(fs.readFile);

const filePromises = ['file1.txt', 'file2.txt', 'file3.txt'].map((fileName) => {
    return readFilePromise(fileName, 'utf8');
});

Promise.all(filePromises)
   .then((dataArray) => {
        dataArray.forEach((data, index) => {
            console.log(`file${index + 1}.txt内容:`, data);
        });
    })
   .catch((err) => {
        console.error('读取文件出错:', err);
    });

在上述代码中，我们首先使用map方法创建了一个包含三个文件读取Promise的数组filePromises，然后使用Promise.all将这些Promise包装成一个新的Promise。当所有文件都成功读取后，.then()方法会被调用，dataArray数组中按顺序保存了每个文件的内容。

Promise.race

Promise.race方法同样用于将多个Promise实例包装成一个新的Promise实例。但与Promise.all不同的是，Promise.race返回的Promise实例会在第一个传入的Promise变为fulfilled或rejected状态时，就立即变为相同的状态，并将第一个完成的Promise的结果或失败原因作为自己的结果或失败原因。

以下是一个Promise.race的示例，模拟多个异步操作竞赛：

function asyncTask1() {
    return new Promise((resolve) => {
        setTimeout(() => {
            resolve('任务1完成');
        }, 3000);
    });
}

function asyncTask2() {
    return new Promise((resolve) => {
        setTimeout(() => {
            resolve('任务2完成');
        }, 1000);
    });
}

Promise.race([asyncTask1(), asyncTask2()])
   .then((result) => {
        console.log('最先完成的任务:', result);
    })
   .catch((error) => {
        console.error('任务出错:', error);
    });

在上述代码中，asyncTask1和asyncTask2分别模拟了两个异步任务，asyncTask2会更快完成。Promise.race会等待第一个完成的任务，这里asyncTask2先完成，所以.then()方法会被调用并输出任务2完成。

async/await

async/await是ES2017引入的异步编程语法糖，它基于Promise构建，使得异步代码看起来更像同步代码，大大提高了代码的可读性。

async函数

async函数是一个异步函数，它返回一个Promise对象。如果async函数返回一个值，这个值会被Promise.resolve()包装成一个已解决的Promise；如果async函数抛出一个错误，这个错误会被Promise.reject()包装成一个已拒绝的Promise。

以下是一个简单的async函数示例：

async function asyncFunction() {
    return '这是一个async函数返回的值';
}

asyncFunction().then((result) => {
    console.log(result);
});

在上述代码中，asyncFunction是一个async函数，它返回一个字符串。这个字符串会被Promise.resolve()包装成一个已解决的Promise，然后通过.then()方法可以获取到返回的值。

await关键字

await关键字只能在async函数内部使用，它用于暂停async函数的执行，等待一个Promise对象变为已解决（fulfilled）状态，并返回Promise的解决值。如果Promise被拒绝（rejected），await会抛出错误，可以使用try...catch块来捕获。

以下是使用async/await改写的文件读取示例：

const fs = require('fs');
const util = require('util');

const readFilePromise = util.promisify(fs.readFile);

async function readFiles() {
    try {
        const data1 = await readFilePromise('file1.txt', 'utf8');
        console.log('file1.txt内容:', data1);

        const data2 = await readFilePromise('file2.txt', 'utf8');
        console.log('file2.txt内容:', data2);

        const data3 = await readFilePromise('file3.txt', 'utf8');
        console.log('file3.txt内容:', data3);
    } catch (err) {
        console.error('读取文件出错:', err);
    }
}

readFiles();

在上述代码中，readFiles是一个async函数，在函数内部使用await等待每个文件读取Promise的完成。await使得代码看起来像是同步执行的，依次读取每个文件，当出现错误时，catch块会捕获并处理错误。

并发操作与错误处理

当需要进行多个并发的异步操作时，我们可以结合Promise.all和async/await来实现。例如，同时读取多个文件并处理可能出现的错误：

const fs = require('fs');
const util = require('util');

const readFilePromise = util.promisify(fs.readFile);

async function readAllFiles() {
    try {
        const filePromises = ['file1.txt', 'file2.txt', 'file3.txt'].map((fileName) => {
            return readFilePromise(fileName, 'utf8');
        });

        const dataArray = await Promise.all(filePromises);
        dataArray.forEach((data, index) => {
            console.log(`file${index + 1}.txt内容:`, data);
        });
    } catch (err) {
        console.error('读取文件出错:', err);
    }
}

readAllFiles();

在上述代码中，首先使用map方法创建多个文件读取的Promise数组，然后使用Promise.all将这些Promise包装起来，await等待所有Promise完成。如果任何一个Promise被拒绝，catch块会捕获并处理错误。

异步流程控制库

除了原生的异步编程方式外，Node.js还有一些优秀的异步流程控制库，如async库，它提供了丰富的工具函数来帮助开发者更方便地管理异步操作。

async.series

async.series用于按顺序执行一组异步任务。它接收一个任务数组，每个任务是一个返回Promise或使用回调的函数，当所有任务都成功完成后，最终的回调函数会被调用。

以下是使用async库的async.series的示例：

const async = require('async');
const fs = require('fs');
const util = require('util');

const readFilePromise = util.promisify(fs.readFile);

async.series([
    (callback) => {
        readFilePromise('file1.txt', 'utf8').then((data) => {
            console.log('file1.txt内容:', data);
            callback(null, data);
        }).catch((err) => {
            callback(err);
        });
    },
    (callback) => {
        readFilePromise('file2.txt', 'utf8').then((data) => {
            console.log('file2.txt内容:', data);
            callback(null, data);
        }).catch((err) => {
            callback(err);
        });
    },
    (callback) => {
        readFilePromise('file3.txt', 'utf8').then((data) => {
            console.log('file3.txt内容:', data);
            callback(null, data);
        }).catch((err) => {
            callback(err);
        });
    }
], (err, results) => {
    if (err) {
        console.error('读取文件出错:', err);
    } else {
        console.log('所有文件读取完成，结果:', results);
    }
});

在上述代码中，async.series中的每个任务都是一个文件读取操作，它们会按顺序执行。如果任何一个任务出错，整个流程会停止，最终的回调函数会收到错误信息。

async.parallel

async.parallel用于并行执行一组异步任务。它同样接收一个任务数组，所有任务会同时开始执行，当所有任务都成功完成后，最终的回调函数会被调用，并将所有任务的结果作为数组传递给回调函数。

以下是async.parallel的示例：

const async = require('async');
const fs = require('fs');
const util = require('util');

const readFilePromise = util.promisify(fs.readFile);

async.parallel([
    (callback) => {
        readFilePromise('file1.txt', 'utf8').then((data) => {
            callback(null, data);
        }).catch((err) => {
            callback(err);
        });
    },
    (callback) => {
        readFilePromise('file2.txt', 'utf8').then((data) => {
            callback(null, data);
        }).catch((err) => {
            callback(err);
        });
    },
    (callback) => {
        readFilePromise('file3.txt', 'utf8').then((data) => {
            callback(null, data);
        }).catch((err) => {
            callback(err);
        });
    }
], (err, results) => {
    if (err) {
        console.error('读取文件出错:', err);
    } else {
        console.log('所有文件读取完成，结果:', results);
    }
});

在上述代码中，三个文件读取任务会并行执行，提高了整体的执行效率。但需要注意的是，如果有大量的并行任务，可能会对系统资源造成较大压力。

async.auto

async.auto可以根据任务之间的依赖关系自动确定任务的执行顺序。它接收一个对象，对象的每个属性代表一个任务，属性值可以是一个函数（该函数的回调参数中可以获取到其他任务的结果），也可以是一个依赖数组。

以下是一个简单的async.auto示例，假设有三个任务，任务3依赖于任务1和任务2的结果：

const async = require('async');

async.auto({
    task1: (callback) => {
        setTimeout(() => {
            console.log('任务1完成');
            callback(null, '任务1的结果');
        }, 1000);
    },
    task2: (callback) => {
        setTimeout(() => {
            console.log('任务2完成');
            callback(null, '任务2的结果');
        }, 1500);
    },
    task3: ['task1', 'task2', (results, callback) => {
        const result1 = results.task1;
        const result2 = results.task2;
        console.log('任务3使用任务1和任务2的结果:', result1, result2);
        setTimeout(() => {
            console.log('任务3完成');
            callback(null, '任务3的结果');
        }, 1000);
    }]
}, (err, results) => {
    if (err) {
        console.error('任务执行出错:', err);
    } else {
        console.log('所有任务完成，结果:', results);
    }
});

在上述代码中，async.auto会先并行执行task1和task2，当这两个任务都完成后，再执行task3，并将task1和task2的结果传递给task3的函数中。

总结异步编程模型在Node.js中的应用场景

  1. I/O操作密集型应用：如文件服务器、Web爬虫等。在文件服务器中，需要频繁地进行文件读取和写入操作，使用异步编程可以避免线程阻塞，提高服务器的并发处理能力。Web爬虫需要同时发起多个网络请求获取网页内容，异步编程可以让爬虫在等待一个请求响应的同时，继续发起其他请求，大大提高了爬取效率。
  2. 实时应用：像实时聊天应用、在线游戏等。在实时聊天应用中，服务器需要实时接收和处理多个客户端的消息，异步编程能够确保服务器在处理一个客户端消息时，不会影响对其他客户端消息的接收和处理，保证了实时性。
  3. 微服务架构：在微服务架构中，各个微服务之间可能需要进行大量的异步通信，例如一个用户服务可能需要调用订单服务获取用户的订单信息，异步编程可以让用户服务在等待订单服务响应的同时，继续处理其他请求，提高整个系统的性能和响应速度。

通过深入理解和掌握Node.js的异步编程模型，开发者能够编写出高效、可维护的代码，充分发挥Node.js在处理高并发、I/O密集型任务方面的优势，为构建强大的应用程序奠定坚实的基础。无论是选择回调函数、Promise、async/await还是使用异步流程控制库，都需要根据具体的应用场景和需求来合理选择，以达到最佳的编程效果。