阻塞事件循环的常见情况

阻塞事件循环的常见情况

Node.js 的事件循环是其非阻塞 I/O 模型的核心，但某些操作会意外阻塞事件循环，导致性能下降甚至服务不可用。以下是几种典型场景：

同步 I/O 操作

在 Node.js 中使用同步文件系统 API 会直接阻塞事件循环：

const fs = require('fs');

// 同步读取文件 - 会阻塞事件循环
const data = fs.readFileSync('/path/to/large/file.txt');
console.log(data.toString());

更严重的是在 HTTP 请求处理中混用同步操作：

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

http.createServer((req, res) => {
  // 每个请求都会同步读取文件
  const content = fs.readFileSync('./template.html');
  res.end(content);
}).listen(3000);

CPU 密集型计算

长时间运行的 JavaScript 计算会独占事件循环：

function fibonacci(n) {
  if (n <= 1) return n;
  return fibonacci(n - 1) + fibonacci(n - 2);
}

// 计算大数斐波那契会严重阻塞
app.get('/fib', (req, res) => {
  const result = fibonacci(45);
  res.send(`Result: ${result}`);
});

加密运算也可能成为性能瓶颈：

const crypto = require('crypto');

app.post('/encrypt', (req, res) => {
  let encrypted = '';
  for (let i = 0; i < 100000; i++) {
    encrypted = crypto.createHash('sha256')
      .update(req.body.data + i)
      .digest('hex');
  }
  res.send(encrypted);
});

复杂 JSON 操作

处理大型 JSON 数据结构时：

const hugeJson = require('./giant-dataset.json');

app.get('/process-data', (req, res) => {
  // 深度遍历巨型JSON
  const processed = JSON.parse(JSON.stringify(hugeJson));
  res.json(processed);
});

正则表达式灾难

某些正则表达式可能引发指数级时间复杂度的匹配：

// 危险的正则表达式
const evilRegex = /^(a+)+$/;

app.post('/check-input', (req, res) => {
  // 恶意输入可能导致长时间匹配
  const isMatch = evilRegex.test(req.body.input);
  res.send({ valid: isMatch });
});

未优化的数据库查询

不当的 ORM 使用方式：

// 使用Sequelize的示例
app.get('/users', async (req, res) => {
  // 获取所有字段和关联数据
  const users = await User.findAll({
    include: [{
      model: Post,
      include: [Comment]
    }]
  });
  res.json(users);
});

未分页的批量操作

一次性处理大量数据：

app.post('/batch-update', async (req, res) => {
  const records = req.body.records; // 假设有10万条记录
  
  // 同步循环处理
  for (const record of records) {
    await db.update(record);
  }
  
  res.send('Done');
});

不当的递归调用

深度递归可能耗尽调用栈：

function deepRecursion(n) {
  if (n === 0) return;
  deepRecursion(n - 1);
}

app.get('/deep', (req, res) => {
  deepRecursion(100000); // 爆栈错误
  res.send('Done');
});

未限制的队列处理

消息队列消费者处理不当：

const queue = require('./message-queue');

queue.consume('jobs', async (job) => {
  // 每个作业都进行复杂处理
  await heavyProcessing(job.data);
});

阻塞的定时器操作

在定时器中执行耗时操作：

setInterval(() => {
  // 每次间隔执行复杂计算
  processLargeDataset();
}, 1000);

未控制的日志输出

高频日志写入可能成为瓶颈：

app.use((req, res, next) => {
  console.log(`Request: ${req.method} ${req.url}`); // 每个请求都同步写入
  next();
});

同步的加密操作

使用同步加密API：

const crypto = require('crypto');

app.post('/sync-encrypt', (req, res) => {
  const key = crypto.randomBytes(32); // 同步生成
  const iv = crypto.randomBytes(16);
  const cipher = crypto.createCipheriv('aes-256-cbc', key, iv);
  let encrypted = cipher.update(req.body.data, 'utf8', 'hex');
  encrypted += cipher.final('hex');
  res.send(encrypted);
});

未分片的流处理

大文件流处理不当：

const fs = require('fs');

app.post('/upload', (req, res) => {
  req.pipe(fs.createWriteStream('./uploads/large-file'));
  // 没有处理背压
  req.on('end', () => res.send('Upload complete'));
});

内存泄漏导致GC频繁

虽然不直接阻塞但会影响性能：

const cache = {};

app.get('/cache', (req, res) => {
  if (!cache[req.query.key]) {
    cache[req.query.key] = generateExpensiveData();
  }
  res.send(cache[req.query.key]);
});

阻塞的进程间通信

同步的child_process操作：

const { execSync } = require('child_process');

app.get('/system-info', (req, res) => {
  const output = execSync('systeminfo').toString();
  res.send(output);
});