Что будет если написать бесконечный цикл в конструкторе Promise?

Краткий ответ

Бесконечный цикл в конструкторе Promise приведет к "зависанию" потока выполнения, при этом промис никогда не перейдет ни в состояние fulfilled, ни в rejected. Это вызовет вечный "pending" (ожидание), заблокирует выполнение кода и может привести к аварийному завершению процесса в некоторых средах.

Подробное объяснение

Как работает конструктор Promise

Конструктор Promise принимает функцию-исполнитель (executor), которая выполняется синхронно и немедленно при создании промиса. Эта функция получает два параметра: resolve и reject.

const promise = new Promise((resolve, reject) => {
  // Этот код выполняется СИНХРОННО сразу же
  console.log('Executing executor...');
  // Асинхронная операция
  setTimeout(() => resolve('Done'), 1000);
});

Что происходит с бесконечным циклом

Если поместить бесконечный цикл в конструктор Promise, функция-исполнитель никогда не завершит свое выполнение:

const promise = new Promise((resolve, reject) => {
  console.log('Начинаем бесконечный цикл...');
  
  // Бесконечный цикл - блокирует поток выполнения
  while (true) {
    // Этот код выполняется вечно
  }
  
  // Эти строки никогда не будут достигнуты:
  console.log('Эта строка никогда не выполнится');
  resolve('Успех'); // Промис никогда не разрешится
});

// Этот код никогда не выполнится:
promise.then(result => {
  console.log('Результат:', result);
});

Последствия такого кода

1. Блокировка Event Loop

JavaScript имеет однопоточную модель выполнения (если не считать Worker'ов). Бесконечный цикл в конструкторе Promise:

• Полностью занимает основной поток выполнения
• Блокирует Event Loop - браузер/Node.js не может обрабатывать другие задачи
• Интерфейс "замирает" в браузере (не реагирует на клики, анимации и т.д.)

2. Promise остается в состоянии "pending"

Поскольку функция-исполнитель никогда не завершается:

• Не вызывается ни resolve(), ни reject()
• Promise навсегда остается в состоянии pending
• Обработчики .then(), .catch(), .finally() никогда не выполнятся

3. Особенности в разных средах

В браузере:

// Пример в браузере
const dangerousPromise = new Promise((resolve) => {
  let i = 0;
  while (true) {  // Браузер "зависнет"
    i++;
    if (i % 1000000 === 0) {
      console.log('Все еще в цикле...'); // Даже это может не выводиться
    }
  }
  resolve('Никогда не случится');
});

// Весь последующий JavaScript-код не выполнится
// UI перестанет отвечать, может потребоваться закрыть вкладку

В Node.js:

// Пример в Node.js
const promise = new Promise((resolve) => {
  console.log('Блокируем цикл событий Node.js...');
  while (true) {
    // Бесконечный цикл
  }
});

// Процесс Node.js заблокируется навсегда
// Придется завершать принудительно (Ctrl+C)

Как избежать подобных проблем

Используйте асинхронные операции правильно

Не выполняйте синхронные блокирующие операции в конструкторе Promise:

// ❌ ПЛОХО - блокирующий код
const badPromise = new Promise((resolve) => {
  // Длительная синхронная операция
  let sum = 0;
  for (let i = 0; i < 1000000000; i++) {
    sum += i;
  }
  resolve(sum); // Блокирует поток во время вычислений
});

// ✅ ХОРОШО - используем асинхронность
const goodPromise = new Promise((resolve) => {
  // Выносим тяжелые вычисления из основного потока
  setTimeout(() => {
    let sum = 0;
    for (let i = 0; i < 1000000000; i++) {
      sum += i;
    }
    resolve(sum);
  }, 0); // Или используем setImmediate/nextTick в Node.js
});

// ✅ ЕЩЕ ЛУЧШЕ - используем Web Workers или worker_threads
// для действительно тяжелых вычислений

Используйте механизмы контроля выполнения

Для предотвращения случайных бесконечных циклов:

function safePromise(executor, timeout = 5000) {
  return new Promise((resolve, reject) => {
    const timer = setTimeout(() => {
      reject(new Error('Promise timeout exceeded'));
    }, timeout);
    
    // Оборачиваем исходный executor
    executor(
      (value) => {
        clearTimeout(timer);
        resolve(value);
      },
      (error) => {
        clearTimeout(timer);
        reject(error);
      }
    );
  });
}

// Использование с защитой от зависания
safePromise((resolve) => {
  // Даже если здесь будет бесконечный цикл,
  // через 5 секунд промис отклонится с ошибкой
  while (true) {
    // Бесконечный цикл
  }
}, 5000).catch(error => {
  console.error('Произошла ошибка:', error.message);
});

Практические рекомендации

1. Конструктор Promise должен быстро завершаться - основную работу делайте в асинхронных колбэках

2. Избегайте тяжелых синхронных вычислений в основном потоке JavaScript

3. Для CPU-интенсивных задач используйте:

   • Web Workers в браузере
   • worker_threads в Node.js
   • child_process в Node.js для изоляции процессов

4. Всегда добавляйте обработку ошибок и таймауты для промисов, которые могут потенциально зависнуть:

Promise.race([
  potentialLongTask(),
  new Promise((_, reject) => 
    setTimeout(() => reject(new Error('Timeout')), 10000)
  )
]).catch(handleError);

Вывод

Бесконечный цикл в конструкторе Promise - это антипаттерн, который нарушает фундаментальные принципы асинхронного программирования в JavaScript. Он приводит к полной блокировке Event Loop, делает интерфейс неотзывчивым и нарушает ожидаемое поведение промисов. Правильное использование промисов предполагает быстрый возврат из функции-исполнителя с последующим асинхронным выполнением реальной работы.