Чем отличаются process.nextTick() и setImmediate() в Node.js?

Чем отличаются process.nextTick() и setImmediate() в Node.js?

Это частый источник путаницы, потому что названия интуитивно противоречат их поведению. process.nextTick() выполняется раньше, чем setImmediate(), несмотря на название последнего. Это связано с архитектурой Event Loop в Node.js.

Визуальное сравнение

┌─────────────────────────────────────┐
│   Синхронный код в стеке (call stack)│
├─────────────────────────────────────┤
│                                     │
│ ↓ После завершения стека ↓          │
│                                     │
├─────────────────────────────────────┤
│ 1. process.nextTick() (ОчередьN)    │ ← СНАЧАЛА!
│    (выполнить ВСЕ nextTick)        │
├─────────────────────────────────────┤
│ 2. Микротасики (Promises)           │
│    (выполнить ВСЕ Promises)        │
├─────────────────────────────────────┤
│ 3. Event Loop фазы                  │
│    - timers (setTimeout)            │
│    - poll (I/O)                    │
│    - check (setImmediate) ← ПОТОМ!  │
│    - close                          │
└─────────────────────────────────────┘

Простой пример

console.log('1. Синхронный код');

process.nextTick(() => {
  console.log('3. process.nextTick()');
});

setImmediate(() => {
  console.log('4. setImmediate()');
});

console.log('2. Конец синхронного кода');

// Вывод:
// 1. Синхронный код
// 2. Конец синхронного кода
// 3. process.nextTick()
// 4. setImmediate()

Различия в деталях

process.nextTick()

Что это: Метод, специфичный для Node.js (не существует в браузере), который добавляет callback в очередь выполняется в текущей фазе Event Loop, но ДО переход к следующей операции.

const fs = require('fs');

fs.readFile('file.txt', (err, data) => {
  // Это callback от I/O (макротаска)
  console.log('1. I/O callback');
  
  process.nextTick(() => {
    // Выполнится перед следующей фазой poll
    console.log('2. nextTick');
  });
});

setImmediate(() => {
  // Выполнится в фазе check
  console.log('3. setImmediate');
});

Характеристики:

• Выполняется ещё раньше, чем Promises
• Очередь обрабатывается ПОЛНОСТЬю в одной итерации
• Может заморозить Event Loop, если циклически вызывать
• Приоритет: САМЫЙ ВЫСОКИЙ

setImmediate()

Что это: Функция, которая добавляет callback в очередь выполняется в фазе check Event Loop, которая наступает после фазы poll (I/O).

console.log('1. Старт');

setTimeout(() => {
  console.log('2. setTimeout (phase: timers)');
}, 0);

setImmediate(() => {
  console.log('3. setImmediate (phase: check)');
});

console.log('4. Конец');

// Вывод:
// 1. Старт
// 4. Конец
// 2. setTimeout
// 3. setImmediate

Характеристики:

• Выполняется в фазе check Event Loop
• Приоритет: выше setTimeout, ниже process.nextTick()
• Более предсказуемо чем setTimeout()
• Используется для операций после I/O

Сравнительная таблица

Практический пример: обработка I/O

const fs = require('fs');

function processFile() {
  console.log('1. Начало');
  
  // Читаем файл
  fs.readFile('data.json', 'utf8', (err, data) => {
    console.log('3. Файл прочитан (poll фаза)');
    
    // Парсим данные в текущей фазе
    const json = JSON.parse(data);
    
    // Выполнить сразу
    process.nextTick(() => {
      console.log('4. nextTick: валидируем данные');
      validateData(json);
    });
    
    // Выполнить после других фаз
    setImmediate(() => {
      console.log('5. setImmediate: сохраняем результат');
      saveToDatabase(json);
    });
  });
  
  // Это выполнится перед I/O
  console.log('2. Инициирована асинхронная операция');
}

processFile();

Проблема: бесконечный nextTick

// ПЛОХО! Блокирует Event Loop
function badRecursion() {
  process.nextTick(() => {
    console.log('Tick');
    badRecursion(); // Бесконечный цикл!
  });
}

badRecursion();
// setTimeout НИКОГДА не выполнится
setTimeout(() => {
  console.log('Я замёрз!');
}, 0);

// ХОРОШО! Периодически даёт Event Loop выполниться
function goodRecursion(count) {
  if (count === 0) return;
  
  setImmediate(() => {
    console.log('Immediate:', count);
    goodRecursion(count - 1);
  });
}

goodRecursion(5);

Использование setImmediate() vs setTimeout()

// Вместо setTimeout(..., 0)
setTimeout(() => {
  // Менее надёжно, зависит от системы
}, 0);

// Используй setImmediate()
setImmediate(() => {
  // Более надёжно, явно указывает намерение
});

Реальный пример: HTTP сервер

const http = require('http');

const server = http.createServer((req, res) => {
  console.log(`[${new Date().toISOString()}] ${req.url}`);
  
  // Критичная операция — выполнить сразу
  process.nextTick(() => {
    console.log('nextTick: логируем запрос');
    logger.log(req);
  });
  
  // I/O операция — выполнить в check фазе
  setImmediate(() => {
    console.log('setImmediate: отправляем ответ');
    res.end('OK');
  });
});

server.listen(3000);

Когда использовать?

process.nextTick():

• Нужна максимальная срочность
• Финализация текущей операции
• Обработка ошибок
• Очень критичные callback'и

setImmediate():

• Обычные асинхронные операции
• После I/O операций
• Рекурсивные обработки больших данных
• Когда надо дать Event Loop дышать

Вывод

Счётчик приоритета:

1. Синхронный код
2. process.nextTick()
3. Promises (микротасики)
4. setTimeout() (timers фаза)
5. I/O callbacks (poll фаза)
6. setImmediate() (check фаза)
7. close callbacks

Правило большого пальца: Если сомневаешься — используй setImmediate(), это безопаснее для Event Loop.