Выполнятся ли два Promise одновременно на двух ядрах

Выполнение двух Promise одновременно на двух ядрах

Этот вопрос касается фундаментального понимания того, как JavaScript работает в браузере. Ответ: Нет, два Promise не будут выполняться параллельно на двух разных ядрах процессора, потому что JavaScript в браузере работает однопоточно (single-threaded).

Однопоточная модель JavaScript

JavaScript использует event loop (цикл событий) и одну главную нить выполнения (main thread). Это означает, что:

• Только одна операция выполняется в один момент времени
• Даже если у вашего компьютера есть многоядерный процессор, браузер использует только одно ядро для выполнения JavaScript
• Другие ядра могут использоваться браузером для других задач (рендеринг, сетевые запросы и т.д.)

Пример кода

const promise1 = new Promise((resolve) => {
  console.log('Promise 1 started');
  const result = expensiveComputation();
  resolve(result);
});

const promise2 = new Promise((resolve) => {
  console.log('Promise 2 started');
  const result = expensiveComputation();
  resolve(result);
});

Promise.all([promise1, promise2]).then(results => {
  console.log('Both promises resolved');
});

// Результат:
// Promise 1 started
// Promise 2 started
// Both promises resolved

Хотя Promise 1 и Promise 2 начинают выполняться в строках 1 и 6, их код выполняется последовательно на одном потоке, а не параллельно.

Параллелизм vs Конкурентность

Параллелизм (Parallelism):

• Несколько операций выполняются одновременно на разных ядрах
• Требует многопоточность
• JavaScript в браузере не поддерживает

Конкурентность (Concurrency):

• Несколько операций чередуются на одном ядре
• JavaScript использует именно этот подход через event loop
• Создает иллюзию параллельности

Event Loop (Цикл событий)

console.log('Start');

setTimeout(() => {
  console.log('Timeout 1');
}, 0);

Promise.resolve().then(() => {
  console.log('Promise 1');
});

console.log('End');

// Результат:
// Start
// End
// Promise 1
// Timeout 1

Очередность:

1. Call Stack: Выполняются синхронные операции (Start, End)
2. Microtask Queue: Выполняются Promise callbacks и другие микротаски
3. Callback Queue: Выполняются setTimeout и другие макротаски

Как достичь истинного параллелизма

1. Web Workers:

Единственный способ работать с несколькими потоками в браузере — использовать Web Workers:

// main.js
const worker = new Worker('worker.js');

worker.postMessage({ data: 'calculate this' });

worker.onmessage = (event) => {
  console.log('Result from worker:', event.data);
};

// worker.js
self.onmessage = (event) => {
  const result = heavyComputation(event.data);
  self.postMessage(result);
};

Web Workers работают в отдельном потоке, параллельно с основным потоком:

// Оба работают параллельно на разных потоках
const worker1 = new Worker('worker.js');
const worker2 = new Worker('worker.js');

worker1.postMessage({ id: 1 });
worker2.postMessage({ id: 2 });

// Обе операции выполняются одновременно на разных ядрах

Promise.all() и параллельность

PROMISE.all() не создает параллельность, только управляет конкурентностью:

const promises = [
  fetch('/api/users'),
  fetch('/api/posts'),
  fetch('/api/comments')
];

Promise.all(promises).then(responses => {
  console.log('All fetches completed');
});

// Все fetch запросы отправляются одновременно (по сети)
// Но их обработка в JavaScript все еще однопоточная

По сетевому каналу данные идут параллельно, но JavaScript обработка — последовательно.

Асинхронность != Параллелизм

async function processSequentially() {
  const result1 = await heavyComputation();
  const result2 = await heavyComputation();
  // result2 начнет выполняться после result1
}

async function processConcurrently() {
  const [result1, result2] = await Promise.all([
    heavyComputation(),
    heavyComputation()
  ]);
  // Обе выполняются "одновременно"
}

// processConcurrently() быстрее, потому что
// вторая операция начнет выполняться сразу,
// не дожидаясь окончания первой

Итог

• JavaScript в браузере: Однопоточный, конкурентный (event loop)
• Promise: Не создают параллельность, только управляют асинхронностью
• Параллелизм в браузере: Только через Web Workers
• Параллелизм в Node.js: Через worker_threads модуль

Для высоконагруженных вычислений используйте Web Workers, а не обычные Promise.