Node.js中事件循环和错误监控的关系

try {
  // 可能会抛出错误的代码
  const result = someSynchronousFunction();
  console.log(result);
} catch (error) {
  // 处理错误
  console.error("发生了同步错误:", error);
}

const EventEmitter = require('events');

class MyEmitter extends EventEmitter {}

const myEmitter = new MyEmitter();

// 模拟异步操作
setTimeout(() => {
  myEmitter.emit('error', new Error('发生了异步错误!'));
}, 100);

myEmitter.on('error', (err) => {
  console.error('捕获到异步错误:', err);
});

console.log("程序继续执行...");

function someAsyncFunction() {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      // 模拟异步操作
      const randomNumber = Math.random();
      if (randomNumber < 0.5) {
        resolve('操作成功!');
      } else {
        reject(new Error('操作失败!'));
      }
    }, 100);
  });
}

someAsyncFunction()
  .then(result => {
    console.log(result);
  })
  .catch(error => {
    console.error('捕获到Promise错误:', error);
  });

console.log("程序继续执行...");

async function runAsyncFunction() {
  try {
    const result = await someAsyncFunction();
    console.log(result);
  } catch (error) {
    console.error('捕获到async/await错误:', error);
  }
}

runAsyncFunction();

console.log("程序继续执行...");

process.on('uncaughtException', (err) => {
  console.error('捕获到未处理的异常:', err);
  // 执行清理操作，例如记录日志、关闭数据库连接等
  // 注意：在捕获到未处理的异常后，最好不要尝试恢复程序状态，而是安全地退出程序
  process.exit(1); // 退出程序
});

// 模拟一个未处理的异常
setTimeout(() => {
  throw new Error('这是一个未处理的异常!');
}, 100);

console.log("程序继续执行...");

process.on('unhandledRejection', (reason, promise) => {
  console.error('捕获到未处理的Promise rejection:', reason, promise);
  // 记录日志，并根据情况决定是否退出程序
});

// 模拟一个未处理的Promise rejection
Promise.reject(new Error('这是一个未处理的Promise rejection!'));

console.log("程序继续执行...");

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

const logStream = fs.createWriteStream('async_hooks.log');

const asyncHook = async_hooks.createHook({
  init(asyncId, type, triggerAsyncId, resource) {
    logStream.write(`init: asyncId=${asyncId}, type=${type}, triggerAsyncId=${triggerAsyncId}\n`);
  },
  before(asyncId) {
    logStream.write(`before: asyncId=${asyncId}\n`);
  },
  after(asyncId) {
    logStream.write(`after: asyncId=${asyncId}\n`);
  },
  destroy(asyncId) {
    logStream.write(`destroy: asyncId=${asyncId}\n`);
  },
  promiseResolve(asyncId) {
    logStream.write(`promiseResolve: asyncId=${asyncId}\n`);
  }
});

asyncHook.enable();

// 模拟异步操作
async function someAsyncOperation() {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      try {
        // 模拟可能抛出错误的代码
        throw new Error('async_hooks 模拟错误');
        resolve('操作成功');
      } catch (err) {
        reject(err);
      }
    }, 100);
  });
}

someAsyncOperation()
  .then(result => console.log(result))
  .catch(err => console.error('async_hooks 捕获错误:', err));

// 关闭日志流
setTimeout(() => {
  logStream.close();
}, 500);