🚀 async/await 마스터하기

이 문서는 Node.js 환경에서 비동기 처리를 위한 Promise와 async/await의 핵심 동작 방식과 동기 방식과의 근본적인 차이점을 설명합니다. 실제 예제를 통해 논블로킹(Non-Blocking) I/O의 원리를 깊이 있게 이해할 수 있도록 구성했습니다.

1. 동기(Synchronous) 처리 방식: 블로킹 (Blocking)

개념: 코드가 작성된 순서대로 한 번에 하나의 작업만 순차적으로 실행됩니다. 특정 작업(특히 파일 읽기/쓰기, 네트워크 요청 등 I/O 작업)이 완료될 때까지 다음 코드의 실행이 중단되는 블로킹(Blocking) 방식으로 동작합니다.

• Node.js 예시: fs.readFileSync, fs.writeFileSync 등 함수명 끝에 Sync가 붙은 함수들이 대표적입니다.

동작 원리:

• 동기 함수가 호출되면, Node.js의 메인 스레드는 해당 작업이 완전히 끝날 때까지 대기 상태에 들어갑니다.
• 이 시간 동안 메인 스레드가 블로킹되어 이벤트 루프는 다른 작업을 처리할 수 없으며, setTimeout, setInterval의 콜백 실행, 네트워크 응답 처리 등이 모두 지연됩니다.

danger

동시에 여러 요청을 효율적으로 처리해야 하는 서버 애플리케이션 환경에서 동기 블로킹 방식은 심각한 성능 저하를 유발할 수 있습니다. 단일 요청 처리 중 다른 모든 요청의 응답이 지연되기 때문입니다.

예시 코드:

const fs = require('fs');

console.log("작업 시작");
// 다음 라인에서 메인 스레드가 파일 읽기 작업 동안 멈춥니다.
try {
  const data = fs.readFileSync('large-file.txt', 'utf8');
  console.log("파일 읽기 완료:", data.substring(0, 50) + "..."); // 위의 작업이 끝나야 실행됨
} catch (err) {
  console.error("파일 읽기 중 오류:", err);
}
console.log("다른 작업 시작"); // 순차적으로 실행됨

2. 비동기(Asynchronous) 처리 방식: 논블로킹 (Non-Blocking)

개념: 특정 작업(특히 I/O)을 백그라운드에서 수행하도록 요청한 후, 그 작업의 완료를 기다리지 않고 즉시 다음 코드를 실행합니다. 작업이 완료되면 나중에 콜백 함수, Promise 등을 통해 결과를 처리하는 논블로킹(Non-Blocking) 방식으로 동작합니다.

• Node.js 기반 기술: 이벤트 루프(Event Loop), 콜백 함수(Callback Functions), 프로미스(Promise) 객체

동작 원리:

• 비동기 함수(예: fs.readFile)가 호출되면, Node.js는 해당 작업을 운영체제(또는 libuv의 스레드 풀)에 위임하고 즉시 다음 코드로 넘어갑니다.
• 메인 스레드는 멈추지 않고 계속해서 다른 코드를 실행하거나, 이벤트 루프를 통해 다른 이벤트(예: 타이머, 네트워크 요청)를 처리합니다.
• 백그라운드 작업이 완료되면, 등록된 콜백 함수나 Promise의 후속 처리 로직( .then 또는 await 다음 코드)이 이벤트 큐(Event Queue)에 추가되고, 이벤트 루프에 의해 적절한 시점에 메인 스레드에서 실행됩니다.

tip

I/O 작업으로 인해 대기하는 시간 동안에도 다른 요청이나 작업을 효율적으로 처리할 수 있어, 높은 처리량(Throughput)과 빠른 응답성(Responsiveness)을 제공합니다.

3. Promise란?

개념: 비동기 작업의 최종 완료(fulfillment) 또는 실패(rejection) 상태와 그 결과 값을 나타내는 객체입니다. 콜백 함수의 중첩으로 발생하는 "콜백 지옥(Callback Hell)" 문제를 해결하고, 비동기 코드를 더욱 체계적이고 가독성 있게 작성하는 데 도움을 줍니다.

상태 (States): Promise는 다음 세 가지 상태 중 하나를 가집니다.

• pending: 초기 상태. 비동기 작업이 아직 완료되거나 실패하지 않은 상태.
• fulfilled (or resolved): 비동기 작업이 성공적으로 완료된 상태. 결과 값을 가집니다.
• rejected: 비동기 작업이 실패한 상태. 실패 이유(오류 객체)를 가집니다.

주요 메소드:

• .then(onFulfilled, onRejected): Promise가 fulfilled 또는 rejected 상태가 되었을 때 호출될 함수를 등록합니다. 새로운 Promise를 반환하여 체이닝(chaining)이 가능합니다.
• .catch(onRejected): Promise가 rejected 상태가 되었을 때만 호출될 함수를 등록합니다. then(null, onRejected)와 유사하게 동작합니다.
• .finally(onFinally): Promise의 성공/실패 여부와 관계없이 작업 완료 후 항상 실행될 함수를 등록합니다.

4. async/await란?

개념: Promise를 기반으로 동작하는 **문법적 설탕(Syntactic Sugar)**입니다. 비동기 코드를 마치 동기 코드처럼 더욱 직관적이고 간결하게 작성할 수 있도록 도와줍니다. async/await를 사용하면 Promise 체이닝보다 가독성이 높은 코드를 작성할 수 있습니다.

async 함수 (async function)

• 함수 선언 시 async 키워드를 사용하면, 해당 함수는 항상 Promise를 반환합니다.
• 함수 내에서 값을 반환하면, 그 값으로 resolve되는 Promise가 반환됩니다.
• 함수 내에서 예외(Exception)가 발생하면, 그 예외로 reject되는 Promise가 반환됩니다.

await 연산자 (await operator)

• async 함수 내에서만 사용할 수 있습니다.
• await 키워드 다음에는 주로 Promise가 위치합니다. (Promise가 아닌 값이 오면, 그 값 자체로 resolve된 Promise처럼 처리됩니다.)
• await는 뒤따르는 Promise가 fulfilled 되거나 rejected 될 때까지 현재 async 함수의 실행을 일시 중지시킵니다. Promise가 fulfilled되면 그 결과 값을 반환하고, rejected되면 예외를 발생시킵니다.
• 핵심 원리: async 함수의 실행은 await 지점에서 잠시 멈추지만, Node.js의 메인 스레드는 절대 멈추지 않습니다 (논블로킹). 제어권은 즉시 이벤트 루프에게 반환되어 다른 작업(다른 요청 처리, 타이머 실행 등)을 계속 처리할 수 있게 됩니다. 해당 Promise가 완료되면, 이벤트 루프는 중단되었던 async 함수의 실행을 이어갑니다.

5. 실전 예시: 코드 비교

아래는 async/await를 사용한 비동기 작업 처리의 일반적인 패턴입니다.

// 이 함수는 Promise를 반환한다고 가정합니다.
// 예: const { readFile } = require('fs').promises;
async function readFileAsync(filePath) {
  // 실제로는 fs.promises.readFile 등을 사용
  return new Promise((resolve, reject) => {
    setTimeout(() => { // 파일 읽기를 흉내 내는 지연
      if (filePath === 'valid-file.txt') {
        resolve(`Content of ${filePath}`);
      } else {
        reject(new Error('File not found or error reading file'));
      }
    }, 1000);
  });
}

async function anotherAsyncTask(inputData) {
  return new Promise(resolve => {
    setTimeout(() => {
      resolve(`Processed: ${inputData}`);
    }, 500);
  });
}

async function processFileOperations() {
  console.log("비동기 작업 흐름 시작");
  try {
    console.log("파일 읽기 시도 (await)...");
    // 여기서 processFileOperations 함수의 실행은 잠시 멈추지만,
    // 이벤트 루프는 다른 작업을 계속 처리할 수 있습니다!
    const fileData = await readFileAsync('valid-file.txt');
    console.log("파일 읽기 완료:", fileData); // 위 await 작업이 끝나면 여기서부터 실행 재개

    console.log("다른 비동기 작업 시작 (await)...");
    const result = await anotherAsyncTask(fileData);
    console.log("다른 비동기 작업 완료:", result);

  } catch (error) {
    console.error("오류 발생:", error.message);
  }
  console.log("모든 비동기 작업 절차 완료");
}

processFileOperations();
console.log("processFileOperations 함수 호출 직후 (아직 내부 await 완료 전)");

상세 예제 코드: 블로킹 vs. 논블로킹 시연

다음 코드는 test_io_delayed.js라는 파일로 저장하여 Node.js 환경에서 직접 실행해보면 그 차이를 명확히 알 수 있습니다.

// test_io_delayed.js

// 필요한 모듈 가져오기
const fs = require('fs'); // 파일 시스템 동기 함수용
const fsPromises = require('fs').promises; // 파일 시스템 비동기 함수용 (Promise 기반)
const path = require('path'); // 파일 경로 처리용

// 테스트용 파일 경로 설정 (코드가 실행되는 디렉터리에 생성됨)
const syncFilePath = path.join(__dirname, 'dummy-sync.txt');
const asyncFilePath = path.join(__dirname, 'dummy-async.txt');
// 파일 크기 (라인 수) - 실제 I/O 시간을 유의미하게 만들기 위해 크게 유지
const FILE_SIZE_LINES = 1000000; // 백만 라인
// 비동기 작업에 추가할 인위적인 지연 시간 (ms)
const ASYNC_DELAY_MS = 350; // 350ms (I/O 외 추가 지연)

// --- 1. 동기 블로킹 예제 함수 ---
function runSyncBlockingExample() {
  console.log("\n--- [시작] 동기 (readFileSync) 블로킹 테스트 ---");
  try {
    console.log(`[Sync] 테스트 파일 생성 시작 (${syncFilePath})...`);
    let fileContent = '';
    for (let i = 0; i < FILE_SIZE_LINES; i++) {
      fileContent += `동기 테스트 파일 라인 ${i + 1}\n`;
    }
    fs.writeFileSync(syncFilePath, fileContent); // 동기 파일 쓰기
    console.log("[Sync] 테스트 파일 생성 완료.");
  } catch (err) {
    console.error("[Sync] 파일 생성 중 오류:", err);
    return; // 오류 발생 시 함수 종료
  }

  let syncIntervalCount = 0;
  console.log("[Sync] 타이머 시작 (100ms 간격). readFileSync 실행 전.");
  const syncTimer = setInterval(() => {
    syncIntervalCount++;
    // 이 로그는 readFileSync가 메인 스레드를 블로킹하는 동안에는 출력되지 않습니다.
    console.log(`[Sync Timer] ${syncIntervalCount * 100}ms 경과 (이벤트 루프 활성화 시 출력)`);
  }, 100);

  console.log("[Sync] >>> readFileSync 호출 시작... 이제 메인 스레드는 여기서 멈춥니다! <<<");
  try {
    const startTime = Date.now();
    const data = fs.readFileSync(syncFilePath, 'utf8'); // 동기 파일 읽기 (블로킹!)
    const endTime = Date.now();
    console.log(`[Sync] readFileSync 완료! ${Buffer.byteLength(data)} 바이트 읽음. 소요 시간: ${endTime - startTime}ms`);
    console.log("[Sync] readFileSync가 완료된 후에야 이 메시지가 출력됩니다. 이후 타이머는 즉시 정리됩니다.");
  } catch (err) {
    console.error("[Sync] 파일 읽기 중 오류:", err);
  } finally {
    clearInterval(syncTimer); // 타이머 정리
    console.log("[Sync] 타이머 종료됨.");
    console.log("--- [종료] 동기 (readFileSync) 블로킹 테스트 ---");
  }
}

// --- 비동기 파일 읽기에 인위적인 지연을 추가하는 헬퍼 함수 ---
async function readFileWithDelay(filePath, encoding, delayMs) {
  // 1. 실제 파일 읽기 (비동기)
  const data = await fsPromises.readFile(filePath, encoding);

  // 2. 인위적인 비동기 지연 추가 (Promise와 setTimeout 사용)
  if (delayMs > 0) {
    console.log(`[Async Helper] ${delayMs}ms 인위적 지연 시작...`);
    await new Promise(resolve => setTimeout(resolve, delayMs));
    console.log(`[Async Helper] ${delayMs}ms 인위적 지연 완료.`);
  }
  // 3. 파일 데이터 반환
  return data;
}

// --- 2. 비동기 논블로킹 예제 함수 ---
// 비동기 작업을 위해 async 함수로 정의
async function runAsyncNonBlockingExample() {
  console.log("\n--- [시작] 비동기 (readFile + 인위적 지연) 논블로킹 테스트 ---");

  // 2-1. 테스트용 대용량 파일 '비동기적'으로 생성
  console.log(`[Async] 테스트 파일 생성 시작 (${asyncFilePath})...`);
  try {
    let fileContent = '';
    for (let i = 0; i < FILE_SIZE_LINES; i++) {
      fileContent += `비동기 테스트 파일 라인 ${i + 1}\n`;
    }
    await fsPromises.writeFile(asyncFilePath, fileContent); // 비동기 파일 쓰기
    console.log("[Async] 테스트 파일 생성 완료.");
  } catch (err) {
    console.error("[Async] 파일 생성 중 오류 발생:", err);
    return; // 오류 발생 시 함수 종료
  }

  // 2-2. 주기적으로 메시지를 출력하는 타이머 설정 (100ms 간격)
  let asyncIntervalCount = 0;
  const asyncTimer = setInterval(() => {
    asyncIntervalCount++;
    // 중요: 이 로그는 아래 await readFileWithDelay 작업이 진행되는 '중에도' 계속 출력됩니다.
    // 이는 이벤트 루프가 멈추지 않고 다른 작업(타이머 콜백)을 처리하고 있음을 의미합니다.
    console.log(`[Async Timer] ${asyncIntervalCount * 100}ms 경과 (이벤트 루프 활성 상태)`);
  }, 100);
  console.log("[Async] 타이머 시작 (100ms 간격). readFileWithDelay 호출 전.");

  // 2-3. 지연이 추가된 비동기 파일 읽기 실행 (논블로킹 지점)
  console.log(`[Async] >>> await readFileWithDelay 호출 시작 (파일 읽기 + ${ASYNC_DELAY_MS}ms 지연)... 메인 스레드는 멈추지 않습니다! <<<`);
  try {
    const startTime = Date.now(); // 전체 작업 시작 시간 기록

    // readFileWithDelay 함수 호출 (내부적으로 await fsPromises.readFile과 await new Promise 사용)
    const data = await readFileWithDelay(asyncFilePath, 'utf8', ASYNC_DELAY_MS);

    const endTime = Date.now(); // 전체 작업 종료 시간 기록
    // 이 로그는 파일 읽기와 추가 지연이 '모두 완료된 시점'에 출력됩니다.
    console.log(`[Async] >>> await readFileWithDelay 완료! <<< ${Buffer.byteLength(data)} 바이트 읽음.`);
    console.log(`[Async] 전체 작업(파일 읽기 + 인위적 지연) 소요 시간: ${endTime - startTime}ms`);
    console.log(`[Async] 파일 읽기 + 지연 작업이 진행되는 동안 타이머가 ${asyncIntervalCount}번 동작했음을 확인할 수 있습니다.`);

  } catch (err) {
    console.error("[Async] 작업 중 오류 발생:", err);
  } finally {
    // 2-4. 타이머 정리
    clearInterval(asyncTimer);
    console.log("[Async] 타이머 종료됨.");
    console.log("--- [종료] 비동기 (readFile + 인위적 지연) 논블로킹 테스트 ---");
  }
}

// --- 3. 예제 실행 및 파일 정리 ---
async function runTests() {
  // 동기 예제 실행
  runSyncBlockingExample();

  // 비동기 예제 실행 전 잠시 대기 (콘솔 출력 구분을 위해)
  console.log("\n잠시 후 비동기 테스트를 시작합니다 (1.5초 대기)...");
  await new Promise(resolve => setTimeout(resolve, 1500));

  // 비동기 예제 실행
  await runAsyncNonBlockingExample();

  // 테스트 완료 후 생성된 임시 파일 삭제 (정리)
  console.log("\n--- 테스트 파일 정리 시작 ---");
  try {
    if (fs.existsSync(syncFilePath)) {
      fs.unlinkSync(syncFilePath);
      console.log(`[정리] ${syncFilePath} 삭제 완료.`);
    }
    // 비동기 파일은 fsPromises.unlink를 사용하거나, 존재 확인 후 동기 삭제도 가능
    try {
      await fsPromises.stat(asyncFilePath); // 파일 존재 확인
      await fsPromises.unlink(asyncFilePath);
      console.log(`[정리] ${asyncFilePath} 삭제 완료.`);
    } catch (statErr) {
      if (statErr.code !== 'ENOENT') { // ENOENT는 'Error NO ENTry' (파일이나 디렉터리 없음)
        console.error(`[정리] ${asyncFilePath} 상태 확인/삭제 중 오류:`, statErr);
      } else {
        console.log(`[정리] ${asyncFilePath} 파일이 이미 없거나 생성되지 않았습니다.`);
      }
    }
  } catch (err) {
    console.error("[정리] 파일 삭제 중 오류 발생:", err);
  }
  console.log("--- 모든 테스트 및 정리 완료 ---");
}

// 전체 테스트 실행
runTests();

---

6. 시연 코드 결과 요약

• 동기 방식 (readFileSync): fs.readFileSync가 실행되는 동안에는 setInterval로 설정한 타이머의 콜백 함수가 전혀 실행되지 않습니다. 이는 메인 스레드가 readFileSync 작업에 의해 완전히 블로킹되었음을 명확히 보여줍니다.
• 비동기 방식 (await fsPromises.readFile + 추가 지연): await fsPromises.readFile (그리고 await new Promise를 통한 인위적 지연) 부분이 실행되는 동안에도 setInterval 타이머는 주기적으로 계속 실행됩니다. 이는 await가 현재 async 함수의 실행 흐름만 일시 중단할 뿐, Node.js의 메인 스레드를 블로킹하지 않고 이벤트 루프가 다른 작업(여기서는 타이머 콜백)을 계속 처리할 수 있도록 한다는 사실을 증명합니다.

---

7. 결론

async/await는 Promise 기반의 비동기 코드를 동기적인 코드 흐름처럼 보이게 만들어 가독성을 크게 향상시킵니다. 하지만 그 내부 동작은 철저히 논블로킹 방식입니다. Promise와 이벤트 루프를 통해 I/O 작업이 처리되는 동안에도 메인 스레드는 다른 요청을 처리할 수 있도록 하여, Node.js의 높은 성능과 반응성을 유지하는 핵심적인 역할을 수행합니다.

따라서 Node.js 개발 시에는 async/await를 적극적으로 활용하여 코드의 가독성과 유지보수성을 높이는 동시에, 시스템 전체의 성능을 최적화하는 것이 중요합니다.