(번역) 이벤트 루프를 차단하지 않기 위한 실용적인 가이드

while (hasWorkToDo) {
  /* 타이머와 I/O 콜백을 실행하고
     들어오는 연결을 확인하기도 하는 등
     여러 가지 작업이 수행됩니다.*/
  doWork();
}

/* setImmediate는 이벤트 루프에
   콜백 함수를 등록합니다. */
setImmediate(() => {
  console.log('This will at some point in the future');
});
/* 끝을 확인할 수 없는
   동기식 작업 입니다. */
findNthPrime(9999999);

/* /computePrimes 경로로 요청이 전송된 경우,
   이 경로는 (절대) 응답을 전송할 수 없고,
   타임 아웃이 발생합니다. */
app.get('/home', () => {
  return response('Welcome Home!');
});

app.get('/computePrimes', () => {
  /* 끝을 확인할 수 없는
     동기식 작업입니다. */
  return response(findNthPrime(9999999));
});

const findNthPrime = num => {
  let i,
    primes = [2, 3],
    n = 5;
  const isPrime = n => {
    let i = 1,
      p = primes[i],
      limit = Math.ceil(Math.sqrt(n));
    while (p <= limit) {
      if (n % p === 0) {
        return false;
      }
      i += 1;
      p = primes[i];
    }
    return true;
  };
  for (i = 2; i <= num; i += 1) {
    while (!isPrime(n)) {
      n += 2;
    }
    primes.push(n);
    n += 2;
  }
  return primes[num - 1];
};

  const isPrime = n => new Promise(
    resolve => {
      let i = 1, p = primes[i],
        limit = Math.ceil(Math.sqrt(n));
      while (p <= limit) {
        if (n % p === 0) {
          return resolve(false);
        }
        i += 1;
        p = primes[i];
      }
      return resolve(true);
    }
  )
  // ...
  while (!await isPrime(n)) {
  //...

const isPrime = n =>
  new Promise(resolve =>
    setImmediate(() => {
      let i = 1,
        p = primes[i],
        limit = Math.ceil(Math.sqrt(n));
      while (p <= limit) {
        if (n % p === 0) {
          return resolve(false);
        }
        i += 1;
        p = primes[i];
      }
      return resolve(true);
    })
  );

const asyncInterval = setInterval(() => {
  console.log('Event loop executed');
  exCount++;
}, 1);
const findNthPrimeAsync = async num => {
  let i,
    primes = [2, 3],
    n = 5;
  const isPrime = n =>
    new Promise(resolve =>
      setImmediate(() => {
        let i = 1,
          p = primes[i],
          limit = Math.ceil(Math.sqrt(n));
        while (p <= limit) {
          if (n % p === 0) {
            return resolve(false);
          }
          i += 1;
          p = primes[i];
        }
        return resolve(true);
      })
    );
  for (i = 2; i <= num; i += 1) {
    while (!(await isPrime(n))) {
      n += 2;
    }
    primes.push(n);
    n += 2;
  }
  return primes[num - 1];
};

console.log('Calculating Sync Prime...');
let syncCount = 0;
const syncInterval = setInterval(() => {
  console.log('Event loop executed');
  exCount++;
}, 1);

const sync = findNthPrime(nth);
console.log('Sync Prime is', sync);
clearInterval(syncInterval);
console.log('Intervals on event loop:', syncCount);

console.log('Calculating Async Prime...');
let asyncCount = 0;
const asyncInterval = setInterval(() => {
  console.log('Event loop executed');
  asyncCount++;
}, 1);

findNthPrimeAsync(nth)
  .then(n => console.log('Async Prime is', n))
  .then(() => clearInterval(asyncInterval))
  .then(() => console.log('Intervals on event loop:', asyncCount));

Calculating Sync Prime...
Sync Prime is 541
Intervals on event loop: 0
Calculating Async Prime...
Event loop executed
Event loop executed
Event loop executed
Event loop executed
Event loop executed
Event loop executed
Async Prime is 541
Intervals on event loop: 6

const nth = 100; // 이 값을 활용합니다.

const findNthPrimeWorker = num =>
  new Promise(resolve => {
    const worker = new Worker(require.resolve('./worker.js'), {
      workerData: num,
    });

    worker.on('message', d => resolve(d));
  });

findNthPrimeWorker(nth);

// worker.js

const findNthPrime = num => {
  // ...
};

parentPort.postMessage(findNthPrime(workerData));