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

Node.js非阻塞I/O与文件系统的交互

2023-09-061.3k 阅读

Node.js 非阻塞 I/O 基础

阻塞与非阻塞 I/O 的概念

在传统的服务器端编程中，I/O 操作（如读取文件、网络请求等）往往是阻塞的。想象一下，当程序发起一个读取文件的操作时，如果是阻塞 I/O，程序会暂停执行，等待文件读取完成后才继续执行后续代码。这就好比你在餐厅点餐，服务员把菜单拿走后，你只能干等着他回来告诉你点的菜有没有，在这个等待过程中，你不能做其他事情。

而 Node.js 采用了非阻塞 I/O 模型。在这种模型下，当程序发起 I/O 操作时，它不会等待操作完成，而是继续执行后续代码。就像在餐厅点餐，你把菜单给服务员后，不用干等着，你可以和朋友聊天或者看看周围环境，服务员处理完你的订单后会通过某种方式（比如叫号）通知你。这样可以极大地提高程序的并发处理能力，因为它可以在等待 I/O 操作完成的同时，去处理其他任务。

Node.js 事件循环机制

非阻塞 I/O 能在 Node.js 中高效运行，离不开事件循环机制。事件循环是 Node.js 实现异步编程的核心机制。简单来说，事件循环会不断地检查事件队列中是否有任务需要处理。当 I/O 操作完成后，相关的回调函数会被放入事件队列。事件循环会从事件队列中取出任务并执行，这样就实现了非阻塞 I/O 的回调处理。

例如，我们有一段代码同时发起多个文件读取操作：

const fs = require('fs');

fs.readFile('file1.txt', 'utf8', (err, data) => {
    if (err) {
        console.error(err);
        return;
    }
    console.log('File 1 content:', data);
});

fs.readFile('file2.txt', 'utf8', (err, data) => {
    if (err) {
        console.error(err);
        return;
    }
    console.log('File 2 content:', data);
});

console.log('Both file read operations initiated.');

在这段代码中，fs.readFile 是一个非阻塞的文件读取操作。当这两个 fs.readFile 调用执行时，它们会立即返回，程序继续执行 console.log('Both file read operations initiated.'); 这一行。而当文件读取操作完成后，相应的回调函数会被放入事件队列，等待事件循环来执行。

文件系统模块简介

常用文件系统操作方法

Node.js 的 fs 模块提供了丰富的文件系统操作方法。这些方法分为阻塞和非阻塞两种形式。

  • 读取文件：
    • 非阻塞形式是 fs.readFile。它接受文件名、编码格式（可选）和回调函数作为参数。回调函数的第一个参数是错误对象（如果有错误发生），第二个参数是读取到的数据。例如：
const fs = require('fs');
fs.readFile('example.txt', 'utf8', (err, data) => {
    if (err) {
        console.error('Error reading file:', err);
        return;
    }
    console.log('File content:', data);
});

- 阻塞形式是 `fs.readFileSync`。它会阻塞程序执行，直到文件读取完成。它接受文件名和编码格式（可选）作为参数，直接返回读取到的数据或者抛出错误。例如：

const fs = require('fs');
try {
    const data = fs.readFileSync('example.txt', 'utf8');
    console.log('File content:', data);
} catch (err) {
    console.error('Error reading file:', err);
}
  • 写入文件：
    • 非阻塞形式是 fs.writeFile。它接受文件名、要写入的数据、选项（可选）和回调函数作为参数。回调函数只有一个错误参数。例如：
const fs = require('fs');
const content = 'This is some text to write to the file.';
fs.writeFile('newFile.txt', content, err => {
    if (err) {
        console.error('Error writing file:', err);
        return;
    }
    console.log('File written successfully.');
});

- 阻塞形式是 `fs.writeFileSync`。它会阻塞程序执行，直到文件写入完成。它接受文件名、要写入的数据和选项（可选）作为参数，没有返回值，如果发生错误则抛出异常。例如：

const fs = require('fs');
const content = 'This is some text to write to the file.';
try {
    fs.writeFileSync('newFile.txt', content);
    console.log('File written successfully.');
} catch (err) {
    console.error('Error writing file:', err);
}
  • 创建目录：
    • 非阻塞形式是 fs.mkdir。它接受目录路径和选项（可选）以及回调函数作为参数。回调函数只有一个错误参数。例如：
const fs = require('fs');
fs.mkdir('newDirectory', err => {
    if (err) {
        console.error('Error creating directory:', err);
        return;
    }
    console.log('Directory created successfully.');
});

- 阻塞形式是 `fs.mkdirSync`。它会阻塞程序执行，直到目录创建完成。它接受目录路径和选项（可选）作为参数，没有返回值，如果发生错误则抛出异常。例如：

const fs = require('fs');
try {
    fs.mkdirSync('newDirectory');
    console.log('Directory created successfully.');
} catch (err) {
    console.error('Error creating directory:', err);
}
  • 删除文件或目录：
    • 对于删除文件，非阻塞形式是 fs.unlink。它接受文件名和回调函数作为参数，回调函数只有一个错误参数。例如：
const fs = require('fs');
fs.unlink('fileToDelete.txt', err => {
    if (err) {
        console.error('Error deleting file:', err);
        return;
    }
    console.log('File deleted successfully.');
});

- 阻塞形式是 `fs.unlinkSync`。它会阻塞程序执行，直到文件删除完成。它接受文件名作为参数，没有返回值，如果发生错误则抛出异常。例如：

const fs = require('fs');
try {
    fs.unlinkSync('fileToDelete.txt');
    console.log('File deleted successfully.');
} catch (err) {
    console.error('Error deleting file:', err);
}

- 对于删除目录，非阻塞形式是 `fs.rmdir`。它接受目录路径和回调函数作为参数，回调函数只有一个错误参数。例如：

const fs = require('fs');
fs.rmdir('directoryToDelete', err => {
    if (err) {
        console.error('Error deleting directory:', err);
        return;
    }
    console.log('Directory deleted successfully.');
});

- 阻塞形式是 `fs.rmdirSync`。它会阻塞程序执行，直到目录删除完成。它接受目录路径作为参数，没有返回值，如果发生错误则抛出异常。例如：

const fs = require('fs');
try {
    fs.rmdirSync('directoryToDelete');
    console.log('Directory deleted successfully.');
} catch (err) {
    console.error('Error deleting directory:', err);
}

流式操作

除了上述基本的文件操作方法，Node.js 的 fs 模块还提供了流式操作。流是一种用于处理大量数据的高效方式，它可以逐块处理数据，而不是一次性将所有数据读入内存。

  • 可读流：通过 fs.createReadStream 创建。例如，我们要读取一个大文件并逐块处理其内容：
const fs = require('fs');
const readableStream = fs.createReadStream('largeFile.txt');
readableStream.on('data', (chunk) => {
    console.log('Received a chunk of data:', chunk.length);
});
readableStream.on('end', () => {
    console.log('All data has been read.');
});

在这个例子中，readableStream 是一个可读流。当有数据可读时，会触发 data 事件，我们可以在事件处理函数中处理接收到的数据块。当所有数据都被读取完后，会触发 end 事件。

  • 可写流：通过 fs.createWriteStream 创建。例如，我们要将数据逐块写入一个文件：
const fs = require('fs');
const dataToWrite = 'This is some data to be written in chunks.';
const writableStream = fs.createWriteStream('newFile.txt');
const chunkSize = 10;
for (let i = 0; i < dataToWrite.length; i += chunkSize) {
    const chunk = dataToWrite.slice(i, i + chunkSize);
    writableStream.write(chunk);
}
writableStream.end();
writableStream.on('finish', () => {
    console.log('All data has been written.');
});

在这个例子中，我们将 dataToWrite 分成若干块，通过 writableStream.write 方法逐块写入文件。当所有数据都写入完成后，调用 writableStream.end 方法，并且可以通过监听 finish 事件来得知写入操作已完成。

非阻塞 I/O 与文件系统的深度交互

并发文件操作

在实际应用中，我们常常需要同时进行多个文件操作。Node.js 的非阻塞 I/O 模型使得并发文件操作变得非常高效。例如，我们有一个需求，要读取多个文件并对其内容进行处理。

const fs = require('fs');
const files = ['file1.txt', 'file2.txt', 'file3.txt'];
const results = [];

files.forEach((file, index) => {
    fs.readFile(file, 'utf8', (err, data) => {
        if (err) {
            console.error(`Error reading ${file}:`, err);
            return;
        }
        results[index] = data;
        if (results.filter(Boolean).length === files.length) {
            // 所有文件都已读取完成
            console.log('All files read successfully:', results);
        }
    });
});

在这段代码中，我们通过 forEach 循环同时发起对多个文件的读取操作。由于 fs.readFile 是非阻塞的，这些读取操作会并发执行。当每个文件读取完成后，将其内容存入 results 数组对应的位置。当 results 数组中所有位置都有数据（即所有文件都读取完成）时，输出所有文件的内容。

然而，这种方式在处理大量文件时可能会遇到问题。因为每个文件读取操作都会占用一定的系统资源，如果同时发起过多的文件读取操作，可能会导致系统资源耗尽。为了解决这个问题，我们可以使用队列和限流的方式。

const fs = require('fs');
const files = ['file1.txt', 'file2.txt', 'file3.txt', 'file4.txt', 'file5.txt'];
const maxConcurrent = 2;
let currentCount = 0;
const results = [];
const fileQueue = files.slice();

function processNextFile() {
    if (fileQueue.length === 0 || currentCount >= maxConcurrent) {
        return;
    }
    currentCount++;
    const file = fileQueue.shift();
    fs.readFile(file, 'utf8', (err, data) => {
        currentCount--;
        if (err) {
            console.error(`Error reading ${file}:`, err);
            return;
        }
        results.push(data);
        processNextFile();
    });
}

while (currentCount < maxConcurrent && fileQueue.length > 0) {
    processNextFile();
}

在这段改进的代码中，我们定义了 maxConcurrent 表示最大并发数。通过 currentCount 来记录当前正在进行的文件读取操作数量。fileQueue 用于存储待处理的文件列表。processNextFile 函数负责从队列中取出文件并发起读取操作，当一个文件读取完成后，减少 currentCount 并继续处理下一个文件。通过这种方式，我们可以有效地控制并发文件操作的数量，避免系统资源耗尽。

文件操作与事件驱动架构

Node.js 的非阻塞 I/O 与文件系统交互非常适合事件驱动架构。我们可以将文件操作与自定义事件结合起来，实现更灵活和可扩展的代码结构。 例如，我们创建一个简单的文件监控系统，当特定文件发生变化时，触发相应的处理逻辑。

const fs = require('fs');
const path = require('path');
const EventEmitter = require('events');

class FileMonitor extends EventEmitter {
    constructor(filePath) {
        super();
        this.filePath = filePath;
        this.lastModified = null;
        this.init();
    }

    init() {
        this.watchFile();
        setInterval(() => {
            this.watchFile();
        }, 5000);
    }

    watchFile() {
        fs.stat(this.filePath, (err, stats) => {
            if (err) {
                console.error('Error getting file stats:', err);
                return;
            }
            if (!this.lastModified) {
                this.lastModified = stats.mtime;
                return;
            }
            if (stats.mtime > this.lastModified) {
                this.lastModified = stats.mtime;
                this.emit('fileChanged');
            }
        });
    }
}

const monitor = new FileMonitor('example.txt');
monitor.on('fileChanged', () => {
    console.log('The file has been changed. Performing some actions...');
    // 这里可以添加文件变化后的具体处理逻辑，比如重新读取文件等
});

在这个例子中，我们创建了一个 FileMonitor 类，它继承自 EventEmitter。通过 fs.stat 方法获取文件的状态信息，比较文件的修改时间来判断文件是否发生变化。如果文件发生变化，触发 fileChanged 事件。我们通过 setInterval 每隔 5 秒检查一次文件状态。这种事件驱动的方式使得代码结构清晰，易于维护和扩展。

错误处理策略

在进行文件系统的非阻塞 I/O 操作时，错误处理非常重要。由于非阻塞操作是异步的，错误不能像同步代码那样通过简单的 try - catch 块捕获。 在 fs 模块的非阻塞方法中，通常通过回调函数的第一个参数来传递错误信息。例如，在 fs.readFile 中：

const fs = require('fs');
fs.readFile('nonexistentFile.txt', 'utf8', (err, data) => {
    if (err) {
        console.error('Error reading file:', err);
        return;
    }
    console.log('File content:', data);
});

当文件不存在时，err 参数会包含错误信息，我们可以在回调函数中进行相应的错误处理。

对于多个文件操作并发执行的情况，我们需要确保每个操作的错误都能被正确处理。以之前并发读取多个文件的例子来说：

const fs = require('fs');
const files = ['file1.txt', 'file2.txt', 'file3.txt'];
const results = [];
let errorCount = 0;

files.forEach((file, index) => {
    fs.readFile(file, 'utf8', (err, data) => {
        if (err) {
            console.error(`Error reading ${file}:`, err);
            errorCount++;
            return;
        }
        results[index] = data;
        if (results.filter(Boolean).length + errorCount === files.length) {
            if (errorCount === 0) {
                console.log('All files read successfully:', results);
            } else {
                console.log(`${errorCount} files had errors.`);
            }
        }
    });
});

在这个改进的代码中，我们通过 errorCount 来记录发生错误的文件数量。当所有文件的操作（无论是成功还是失败）都完成后，根据 errorCount 的值来判断是否所有文件都成功读取，并进行相应的处理。

另外，在使用流进行文件操作时，错误处理也很关键。例如，在可读流中：

const fs = require('fs');
const readableStream = fs.createReadStream('nonexistentFile.txt');
readableStream.on('error', (err) => {
    console.error('Error reading file with stream:', err);
});
readableStream.on('data', (chunk) => {
    console.log('Received a chunk of data:', chunk.length);
});
readableStream.on('end', () => {
    console.log('All data has been read.');
});

在这个例子中，我们通过监听可读流的 error 事件来捕获文件读取过程中可能发生的错误，比如文件不存在等情况。

性能优化与最佳实践

合理使用缓存

在文件系统操作中，合理使用缓存可以显著提高性能。例如，如果你的应用程序需要频繁读取某个配置文件，每次都从磁盘读取会消耗大量的时间和资源。我们可以在内存中缓存该文件的内容。

const fs = require('fs');
let configCache = null;

function getConfig() {
    if (configCache) {
        return configCache;
    }
    try {
        const data = fs.readFileSync('config.json', 'utf8');
        configCache = JSON.parse(data);
        return configCache;
    } catch (err) {
        console.error('Error reading config file:', err);
        return null;
    }
}

在这个例子中，getConfig 函数首先检查 configCache 是否有值。如果有，则直接返回缓存的配置数据。如果没有，则读取配置文件，解析并缓存数据后返回。这样，在后续的调用中，如果配置文件没有变化，就可以直接从内存中获取数据，大大提高了读取效率。

然而，需要注意的是，如果配置文件可能会在运行时被修改，我们需要有相应的机制来更新缓存。比如，可以结合前面提到的文件监控功能，当文件发生变化时，重新读取并更新缓存。

const fs = require('fs');
const path = require('path');
const EventEmitter = require('events');

class ConfigMonitor extends EventEmitter {
    constructor(filePath) {
        super();
        this.filePath = filePath;
        this.configCache = null;
        this.lastModified = null;
        this.init();
    }

    init() {
        this.loadConfig();
        this.watchFile();
        setInterval(() => {
            this.watchFile();
        }, 5000);
    }

    loadConfig() {
        try {
            const data = fs.readFileSync(this.filePath, 'utf8');
            this.configCache = JSON.parse(data);
        } catch (err) {
            console.error('Error reading config file:', err);
        }
    }

    watchFile() {
        fs.stat(this.filePath, (err, stats) => {
            if (err) {
                console.error('Error getting file stats:', err);
                return;
            }
            if (!this.lastModified) {
                this.lastModified = stats.mtime;
                return;
            }
            if (stats.mtime > this.lastModified) {
                this.lastModified = stats.mtime;
                this.loadConfig();
                this.emit('configChanged');
            }
        });
    }

    getConfig() {
        return this.configCache;
    }
}

const configMonitor = new ConfigMonitor('config.json');
configMonitor.on('configChanged', () => {
    console.log('Config file has been changed.');
});

const config = configMonitor.getConfig();
console.log('Current config:', config);

在这个改进的代码中，ConfigMonitor 类不仅缓存了配置文件的内容，还通过文件监控机制，当配置文件发生变化时，重新加载配置并触发 configChanged 事件。这样可以保证在配置文件更新时，应用程序能及时获取最新的配置数据。

优化流操作

在使用流进行文件操作时，有一些优化技巧可以提高性能。

  • 设置适当的缓冲区大小：在创建可读流时，可以通过 highWaterMark 选项设置缓冲区大小。默认情况下，highWaterMark 为 64KB。如果处理的是非常大的文件，适当增大缓冲区大小可以减少数据读取的次数，提高性能。例如：
const fs = require('fs');
const readableStream = fs.createReadStream('largeFile.txt', { highWaterMark: 1024 * 1024 }); // 设置为 1MB
readableStream.on('data', (chunk) => {
    console.log('Received a chunk of data:', chunk.length);
});
readableStream.on('end', () => {
    console.log('All data has been read.');
});

在这个例子中，我们将缓冲区大小设置为 1MB，这样每次读取的数据量更大，在一定程度上可以提高读取效率。

  • 管道操作：在需要将一个流的数据传输到另一个流时，使用管道（pipe）操作可以提高效率。例如，我们要将一个文件的内容复制到另一个文件：
const fs = require('fs');
const readableStream = fs.createReadStream('sourceFile.txt');
const writableStream = fs.createWriteStream('destinationFile.txt');
readableStream.pipe(writableStream);

在这个例子中，readableStream.pipe(writableStream) 会自动处理数据的读取和写入，并且会优化数据的流动，避免数据在内存中堆积。它会在可读流有数据时，自动将数据写入可写流，直到可读流结束。

避免不必要的文件操作

在编写代码时，要尽量避免不必要的文件操作。例如，不要在循环中频繁地打开和关闭文件。如果需要多次写入文件，最好一次性将数据准备好，然后再进行写入操作。

const fs = require('fs');
const dataArray = ['line1', 'line2', 'line3'];
const dataToWrite = dataArray.join('\n') + '\n';
fs.writeFile('output.txt', dataToWrite, err => {
    if (err) {
        console.error('Error writing file:', err);
        return;
    }
    console.log('File written successfully.');
});

在这个例子中，我们将需要写入文件的多行数据先通过 join 方法组合成一个字符串，然后一次性写入文件，而不是循环多次打开和写入文件，这样可以减少文件系统的开销，提高性能。

另外，在进行文件操作之前，最好先检查文件或目录是否存在，避免不必要的错误。例如，在删除文件之前：

const fs = require('fs');
const path = require('path');
const filePath = 'fileToDelete.txt';
if (fs.existsSync(filePath)) {
    fs.unlink(filePath, err => {
        if (err) {
            console.error('Error deleting file:', err);
            return;
        }
        console.log('File deleted successfully.');
    });
} else {
    console.log('File does not exist. No need to delete.');
}

在这个例子中，通过 fs.existsSync 方法先检查文件是否存在，然后再进行删除操作，这样可以避免因文件不存在而导致的错误。

通过合理使用缓存、优化流操作以及避免不必要的文件操作等性能优化策略和最佳实践，可以使基于 Node.js 的后端应用在与文件系统进行非阻塞 I/O 交互时更加高效和稳定。这些技巧不仅适用于简单的文件处理场景，在大型项目中处理复杂的文件系统操作时也同样重要。同时，随着应用需求的不断变化和发展，我们需要根据实际情况灵活运用这些方法，并不断探索新的优化方式，以提升应用的整体性能。在实际开发过程中，结合性能测试工具，如 benchmark 等，可以更准确地评估优化效果，帮助我们找到最适合具体场景的优化方案。例如，使用 benchmark 来比较不同缓冲区大小设置下文件读取的性能差异，从而选择最优的配置。此外，还需要关注操作系统和硬件环境对文件系统操作性能的影响，在不同的平台上进行测试和优化，以确保应用在各种环境下都能达到最佳性能表现。