Unit 2.3 — 4분면 매트릭스 (실전 예제)

F-LAB JAVA · 4주차 · Phase 2 · Sync/Async × Blocking/Non-Blocking 4분면
★ 마스터 Unit — 면접 단골 (★★★) + 🏆 Phase 2 완주

📌 학습 목표

이 Unit을 끝내면 다음을 답할 수 있어야 한다.

4분면 매트릭스 (Sync/Async × Blocking/Non-Blocking) 의 전체 구조는?
Sync + Blocking (전통 IO) 의 동작과 예는?
Sync + Non-Blocking (NIO Polling) 의 동작과 예는?
Async + Blocking (Future.get) 의 동작과 예는?
Async + Non-Blocking (CompletableFuture) 의 동작과 예는?
"Async + Blocking 이 진정한 비동기가 아니다" 의 의미는?
실무에서 가장 권장되는 조합 과 그 이유는?
각 조합의 스레드 효율 차이는?
두 축의 독립성 을 코드로 증명하면?

🎯 핵심 한 문장

4분면 매트릭스는 Sync/Async (작업 순서 축) 와 Blocking/Non-Blocking (제어권 축) 의 독립적 조합으로 4가지를 만들어낸다.
Sync + Blocking (전통 IO, Socket.read()) — 가장 직관적이지만 가장 비효율 (제어권 잃고 결과 확인).
Sync + Non-Blocking (NIO Polling, channel.read() 가 0 반환) — 제어권 유지하며 반복 확인.
Async + Blocking (Future.get()) — 작업은 비동기로 시작하지만 결과 회수 시 블로킹 (진정한 비동기 아님).
Async + Non-Blocking (CompletableFuture, Callback) — 가장 효율적, 작업도 비동기 + 결과도 콜백 (블로킹 X).
실무 권장은 Async + Non-Blocking — 적은 스레드로 높은 처리량, 단 복잡도는 가장 높다.

비유 — 택배 받기

4분면 = 택배 받는 4가지 방식:

Sync + Blocking (전통):
  택배 올 때까지 문 앞에 서서 기다림
  - 다른 일 못 함 (제어권 잃음)
  - 도착 직접 확인 (동기)

Sync + Non-Blocking (Polling):
  가끔 문 열어 "왔나?" 확인
  - 다른 일 하다가 (제어권 유지)
  - 직접 확인하러 감 (동기)

Async + Blocking (Future.get):
  택배 기사에게 맡기고 (비동기 시작)
  도착 시점에 결국 문 앞 대기 (블로킹)

Async + Non-Blocking (CompletableFuture):
  택배 맡기고 (비동기)
  도착하면 벨 누르라고 (콜백, 논블로킹)
  - 가장 효율적

→ 두 축의 4가지 조합 = 4가지 처리 방식.

🧭 9개 섹션 로드맵

1. 4분면 매트릭스 전체 구조
2. Sync + Blocking (전통 IO)
3. Sync + Non-Blocking (NIO Polling)
4. Async + Blocking (Future.get)
5. Async + Non-Blocking (CompletableFuture)
6. "Async + Blocking이 진정한 비동기가 아니다"
7. 실무 권장 조합
8. Phase 2 완주 정리
9. 면접 + 자기 점검 + Phase 2 졸업 시험

1️⃣ 4분면 매트릭스 전체 구조

1.1 매트릭스

            Blocking          Non-Blocking
         ┌────────────────┬──────────────────┐
  Sync   │ 전통 IO         │ NIO Polling       │
         │ Socket.read()  │ read() == 0       │
         │ 가장 단순       │ 제어권 유지+확인   │
         ├────────────────┼──────────────────┤
  Async  │ Future.get()   │ CompletableFuture │
         │ 비동기+블로킹    │ Callback          │
         │ "가짜 비동기"   │ 가장 효율적        │
         └────────────────┴──────────────────┘

1.2 두 축의 의미

가로축 — Blocking/Non-Blocking (제어권):
  - Blocking: 호출 시 제어권 잃고 대기
  - Non-Blocking: 즉시 제어권 반환

세로축 — Sync/Async (작업 순서/통보):
  - Sync: 완료 확인하고 진행
  - Async: 완료 안 기다림, 통보

1.3 4가지 조합 요약

조합	예시	특징
Sync + Blocking	Socket.read()	단순, 비효율
Sync + Non-Blocking	NIO Polling	제어권 유지 + 확인
Async + Blocking	Future.get()	가짜 비동기
Async + Non-Blocking	CompletableFuture	효율, 복잡

1.4 효율 순서

스레드 효율 (낮음 → 높음):

1. Sync + Blocking (최저)
   - 1 작업 = 1 스레드 점유

2. Async + Blocking
   - 작업 비동기, 회수 블로킹

3. Sync + Non-Blocking
   - 제어권 유지, polling

4. Async + Non-Blocking (최고)
   - 적은 스레드, 콜백

복잡도는 반대 (Async+NonBlocking 이 가장 복잡)

1.5 시각화 — 스레드 사용

Sync + Blocking:
  스레드: [작업1 대기────][작업2 대기────]
          1 스레드 = 1 작업 (대기 점유)

Async + Non-Blocking:
  스레드: [작업1 시작][작업2 시작][작업3 시작]
          [콜백1][콜백2][콜백3]
          적은 스레드 = 많은 작업

1.6 ILIC 의 4가지 예

public class FourQuadrants {
    
    // 1. Sync + Blocking
    public Shipment syncBlocking(Long id) {
        return repository.findById(id);   // 대기 + 확인
    }
    
    // 2. Sync + Non-Blocking (polling)
    public Shipment syncNonBlocking(Future<Shipment> f) throws Exception {
        while (!f.isDone()) { doOther(); }   // 확인 + 제어권 유지
        return f.get();
    }
    
    // 3. Async + Blocking
    public Shipment asyncBlocking(Long id) throws Exception {
        Future<Shipment> f = executor.submit(() -> repository.findById(id));
        return f.get();   // 비동기 + 블로킹 회수
    }
    
    // 4. Async + Non-Blocking
    public CompletableFuture<Shipment> asyncNonBlocking(Long id) {
        return CompletableFuture.supplyAsync(() -> repository.findById(id));
    }
}

1.7 자기 점검 답변

4분면 매트릭스의 구조는?

답:
1. 두 축:

가로: Blocking/Non-Blocking (제어권)
세로: Sync/Async (작업 순서)

4가지:
- Sync+Blocking (전통 IO)
- Sync+Non-Blocking (Polling)
- Async+Blocking (Future.get)
- Async+Non-Blocking (CompletableFuture)
효율:
- Sync+Blocking 최저
- Async+Non-Blocking 최고
독립적:
- 두 축은 별개
- 4가지 모두 가능

2️⃣ Sync + Blocking (전통 IO)

2.1 정의

Sync + Blocking:

  - 동기: 완료 확인하고 진행
  - 블로킹: 제어권 잃고 대기

  → 작업 완료까지 대기 + 결과 직접 받음

가장 직관적, 가장 비효율

2.2 동작 흐름

Sync + Blocking 흐름:

호출자:
  1. read() 호출
  2. 제어권 넘김 (블로킹)
  3. 데이터 올 때까지 대기
  4. 데이터 받음 (동기 — 확인)
  5. 다음 코드

  대기 + 직접 결과

2.3 코드 예시

// 전통 IO (Sync + Blocking)
public String readFromSocket(Socket socket) throws IOException {
    InputStream in = socket.getInputStream();
    byte[] buffer = new byte[1024];
    
    int read = in.read(buffer);   // ★ Sync + Blocking
    // - 블로킹: 데이터 올 때까지 대기 (제어권 잃음)
    // - 동기: 결과 직접 받음
    
    return new String(buffer, 0, read);
}

// DB 조회도 동일
public Shipment fetchSync(Long id) {
    return repository.findById(id);   // Sync + Blocking
}

2.4 특징

Sync + Blocking 특징:

장점:
  - 가장 단순
  - 직관적 코드 흐름
  - 디버깅 쉬움
  - 결과 바로 사용

단점:
  - 스레드 대기 (자원 낭비)
  - 많은 동시 요청 = 많은 스레드
  - 처리량 한계
  - C10K 문제

2.5 언제 사용

Sync + Blocking 적합:

  - 단순한 애플리케이션
  - 적은 동시성
  - 가독성 우선
  - 전통적 웹 서버 (스레드 풀)

대부분의 전통 자바 서버:
  - Spring MVC (블로킹)
  - JDBC
  - 톰캣 스레드 풀

2.6 ILIC 의 맥락

// ILIC 의 일반적 처리 (Sync + Blocking)
@Service
public class ShipmentService {
    
    public ShipmentDetail getDetail(Long id) {
        // 모두 Sync + Blocking
        Shipment shipment = repository.findById(id);          // 대기
        Company consignee = companyRepo.findById(shipment.getConsigneeId());  // 대기
        List<ShipmentItem> items = itemRepo.findByShipmentId(id);  // 대기
        
        // 순차 + 각각 블로킹
        // 단순하지만 느림 (3번 대기)
        return new ShipmentDetail(shipment, consignee, items);
    }
}
// Spring MVC + JDBC = 전형적 Sync + Blocking

2.7 자기 점검 답변

Sync + Blocking 은?

답:
1. 정의:

동기 (확인) + 블로킹 (대기)
전통 IO

동작:
- 완료까지 대기
- 결과 직접
예:
- Socket.read()
- JDBC
- Spring MVC
특징:
- 단순, 직관적
- 비효율 (스레드 대기)

3️⃣ Sync + Non-Blocking (NIO Polling)

3.1 정의

Sync + Non-Blocking:

  - 동기: 완료 확인하고 진행
  - 논블로킹: 제어권 유지

  → 제어권 유지하며 반복 확인 (polling)

NIO Polling 방식

3.2 동작 흐름

Sync + Non-Blocking 흐름:

호출자:
  1. read() 호출 (논블로킹)
  2. 즉시 반환 (0 또는 데이터)
  3. 데이터 없으면 다른 일
  4. 다시 read() (polling)
  5. 데이터 있으면 처리 (동기 확인)

  제어권 유지 + 반복 확인

3.3 코드 예시

// NIO Polling (Sync + Non-Blocking)
public String readNonBlockingPolling(SocketChannel channel) throws IOException {
    channel.configureBlocking(false);   // 논블로킹 모드
    ByteBuffer buffer = ByteBuffer.allocate(1024);
    
    while (true) {
        int read = channel.read(buffer);   // ★ Sync + Non-Blocking
        // - 논블로킹: 0 즉시 반환 (제어권 유지)
        // - 동기: 결과 확인하며 진행
        
        if (read > 0) {
            buffer.flip();
            return StandardCharsets.UTF_8.decode(buffer).toString();
        } else if (read == 0) {
            // 데이터 없음 (대기 X)
            doOtherWork();   // 다른 일
            // 다시 시도 (polling)
        } else {
            return null;   // 연결 종료
        }
    }
}

3.4 특징

Sync + Non-Blocking 특징:

장점:
  - 제어권 유지 (다른 일 가능)
  - 단일 스레드로 여러 작업

단점:
  - busy waiting (CPU 낭비)
  - polling 간격 조절 어려움
  - 복잡

개선:
  - Selector 사용 (효율적 polling)

3.5 Polling 의 문제

Polling 의 트레이드오프:

너무 자주:
  - CPU 낭비 (busy waiting)
  - while(read==0) 무한 확인

너무 가끔:
  - 응답 지연

해결:
  - Selector (이벤트 기반)
  - select() 가 효율적 대기

3.6 Selector 로 개선

// Selector — 효율적 Sync + Non-Blocking
public void selectorBased() throws IOException {
    Selector selector = Selector.open();
    channel.configureBlocking(false);
    channel.register(selector, SelectionKey.OP_READ);
    
    while (true) {
        selector.select();   // 준비된 채널까지 (효율적, busy X)
        
        for (SelectionKey key : selector.selectedKeys()) {
            if (key.isReadable()) {
                read((SocketChannel) key.channel());   // 동기 처리
            }
        }
        selector.selectedKeys().clear();
    }
}
// busy waiting 회피
// 여러 채널 1 스레드

3.7 ILIC 의 맥락

// Future polling (Sync + Non-Blocking 유사)
public class ShipmentPolling {
    
    public Shipment fetchWithPolling(Long id) throws Exception {
        Future<Shipment> future = executor.submit(() -> repository.findById(id));
        
        // 논블로킹 확인 (제어권 유지) + 동기 (결과 확인)
        while (!future.isDone()) {
            // 다른 일
            processOtherTasks();
            Thread.sleep(10);   // polling 간격
        }
        
        return future.get();   // 완료 (동기 결과)
    }
    
    private void processOtherTasks() {
        // 다른 작업
    }
}

3.8 자기 점검 답변

Sync + Non-Blocking 은?

답:
1. 정의:

동기 (확인) + 논블로킹 (제어권 유지)
NIO Polling

동작:
- 즉시 반환 (0 가능)
- 반복 확인 (polling)
예:
- channel.read() 논블로킹
- Future.isDone() polling
문제:
- busy waiting
- Selector 로 개선

4️⃣ Async + Blocking (Future.get)

4.1 정의

Async + Blocking:

  - 비동기: 작업을 백그라운드로 시작
  - 블로킹: 결과 받을 때 대기

  → 작업은 비동기지만 결과 회수가 블로킹

Future.get() 의 전형

4.2 동작 흐름

Async + Blocking 흐름:

호출자:
  1. submit() — 작업 비동기 시작
  2. Future 반환 (즉시)
  3. 다른 일 (작업 진행 중)
  4. future.get() — 결과 회수 (★ 블로킹)
  5. 완료까지 대기
  6. 결과 받음

  비동기 시작 + 블로킹 회수

4.3 코드 예시

// Async + Blocking (Future.get)
public Shipment asyncBlocking(Long id) throws Exception {
    // 비동기 시작
    Future<Shipment> future = executor.submit(() -> {
        return repository.findById(id);   // 백그라운드 실행
    });
    
    // 다른 일 (작업 진행 중)
    doOtherWork();
    
    // ★ 블로킹 회수
    Shipment result = future.get();   // 완료까지 대기 (블로킹)
    return result;
}

4.4 특징

Async + Blocking 특징:

장점:
  - 작업 시작 후 약간의 다른 일 가능
  - 여러 작업 동시 시작 가능

단점:
  - 결국 get() 에서 블로킹
  - 진정한 비동기 X (다음 섹션)
  - 스레드 대기

흔한 패턴:
  - Future.get()
  - 여러 작업 후 모두 get

4.5 여러 작업의 Async + Blocking

// 여러 작업 동시 시작 후 블로킹 회수
public List<Shipment> fetchManyAsyncBlocking(List<Long> ids) throws Exception {
    // 모두 비동기 시작
    List<Future<Shipment>> futures = ids.stream()
        .map(id -> executor.submit(() -> repository.findById(id)))
        .toList();
    // 동시 시작 (비동기)
    
    // 각각 블로킹 회수
    List<Shipment> results = new ArrayList<>();
    for (Future<Shipment> future : futures) {
        results.add(future.get());   // 블로킹 (하지만 이미 진행 중)
    }
    return results;
    // 동시 시작 덕에 순차보다 빠름
    // 하지만 get() 은 블로킹
}

4.6 ILIC 의 맥락

@Service
public class ShipmentAsyncBlockingService {
    
    private final ExecutorService executor = Executors.newFixedThreadPool(10);
    
    public ShipmentReport generateReport(Long id) throws Exception {
        // 여러 작업 비동기 시작
        Future<Shipment> shipmentF = executor.submit(() -> repository.findById(id));
        Future<Tracking> trackingF = executor.submit(() -> trackingApi.fetch(id));
        Future<Invoice> invoiceF = executor.submit(() -> invoiceApi.fetch(id));
        // 3개 동시 시작 (비동기)
        
        // 블로킹 회수 (각각 대기)
        Shipment shipment = shipmentF.get();   // 블로킹
        Tracking tracking = trackingF.get();   // 블로킹
        Invoice invoice = invoiceF.get();      // 블로킹
        
        return new ShipmentReport(shipment, tracking, invoice);
        // 동시 시작으로 순차보다 빠르나
        // get() 은 블로킹 (스레드 대기)
    }
}

4.7 자기 점검 답변

Async + Blocking 은?

답:
1. 정의:

비동기 시작 + 블로킹 회수
Future.get()

동작:
- submit (비동기)
- get (블로킹)
예:
- Future.get()
- 여러 작업 후 get
특징:
- 동시 시작 (빠름)
- get 블로킹 (진정한 비동기 X)

5️⃣ Async + Non-Blocking (CompletableFuture)

5.1 정의

Async + Non-Blocking:

  - 비동기: 작업 백그라운드
  - 논블로킹: 결과도 콜백 (대기 X)

  → 작업 비동기 + 결과 콜백 (블로킹 X)

가장 효율적
CompletableFuture, Callback

5.2 동작 흐름

Async + Non-Blocking 흐름:

호출자:
  1. supplyAsync() — 비동기 시작
  2. CompletableFuture 반환 (즉시)
  3. thenAccept() — 콜백 등록
  4. 호출자 계속 (대기 X)
  ...
  N. 작업 완료 → 콜백 자동 실행

  비동기 + 콜백 (블로킹 없음)

5.3 코드 예시

// Async + Non-Blocking (CompletableFuture)
public void asyncNonBlocking(Long id) {
    CompletableFuture
        .supplyAsync(() -> repository.findById(id))   // 비동기 시작
        .thenApply(this::enrich)                       // 완료 시 변환 (콜백)
        .thenAccept(this::process)                     // 완료 시 처리 (콜백)
        .exceptionally(error -> {                      // 에러 콜백
            log.error("Failed", error);
            return null;
        });
    
    // 호출자는 즉시 진행 (블로킹 X)
    doOtherWork();
    // 작업 완료 시 콜백 자동
}

5.4 특징

Async + Non-Blocking 특징:

장점:
  - 가장 효율적
  - 적은 스레드로 높은 처리량
  - 블로킹 X
  - 체이닝 (조합 쉬움)

단점:
  - 가장 복잡
  - 콜백 흐름 추적 어려움
  - 디버깅 어려움
  - 에러 처리 복잡

5.5 체이닝의 강력함

// 여러 비동기 작업 조합
public CompletableFuture<Report> generateReportAsync(Long id) {
    return CompletableFuture
        .supplyAsync(() -> repository.findById(id))   // 1. 조회
        .thenCompose(shipment -> {
            // 2. 독립적 작업 동시 (비동기)
            CompletableFuture<Tracking> tracking = fetchTrackingAsync(shipment);
            CompletableFuture<Invoice> invoice = fetchInvoiceAsync(shipment);
            
            // 3. 둘 다 완료 시 결합 (논블로킹)
            return tracking.thenCombine(invoice, 
                (t, i) -> new Report(shipment, t, i));
        });
    // 전체가 논블로킹
    // 블로킹 없이 조합
}

5.6 주요 메서드

// CompletableFuture 주요 메서드 (Phase 8 에서 정밀)

// 변환
.thenApply(x -> x * 2)          // 값 변환
.thenCompose(x -> anotherFuture) // Future 연결 (flatMap)

// 소비
.thenAccept(x -> print(x))      // 결과 소비
.thenRun(() -> log("done"))     // 결과 무관 실행

// 결합
.thenCombine(other, (a, b) -> a + b)  // 두 Future 결합
.allOf(f1, f2, f3)              // 모두 완료
.anyOf(f1, f2, f3)              // 하나 완료

// 에러
.exceptionally(e -> fallback)   // 에러 처리
.handle((result, error) -> ...)  // 성공/실패 모두

5.7 ILIC 의 맥락

@Service
public class ShipmentAsyncNonBlockingService {
    
    // 완전 논블로킹 처리
    public CompletableFuture<ShipmentReport> generateReportAsync(Long id) {
        return CompletableFuture
            .supplyAsync(() -> repository.findById(id), ioExecutor)
            .thenCompose(shipment -> {
                // 독립 작업 동시
                var trackingF = fetchTrackingAsync(shipment.getBlNo());
                var invoiceF = fetchInvoiceAsync(shipment.getId());
                var customsF = fetchCustomsAsync(shipment.getId());
                
                return CompletableFuture.allOf(trackingF, invoiceF, customsF)
                    .thenApply(v -> new ShipmentReport(
                        shipment,
                        trackingF.join(),
                        invoiceF.join(),
                        customsF.join()));
            })
            .exceptionally(error -> {
                log.error("Report generation failed for {}", id, error);
                return ShipmentReport.empty(id);
            });
        // 블로킹 없이 여러 작업 조합
        // 적은 스레드로 높은 처리량
    }
}

5.8 자기 점검 답변

Async + Non-Blocking 은?

답:
1. 정의:

비동기 + 콜백 (블로킹 X)
CompletableFuture

동작:
- supplyAsync (비동기)
- thenAccept (콜백)
- 호출자 계속
특징:
- 가장 효율적
- 적은 스레드 + 높은 처리량
- 가장 복잡
메서드:
- thenApply/Compose
- thenCombine, allOf

6️⃣ "Async + Blocking이 진정한 비동기가 아니다"

6.1 의미

"Async + Blocking 이 진정한 비동기가 아니다":

  작업은 비동기로 시작하지만
  결과 회수 (get) 가 블로킹.

  → 결국 그 지점에서 스레드 대기
  → 비동기의 이점 (스레드 효율) 상실
  → "무늬만 비동기"

6.2 왜 진정한 비동기가 아닌가

Future.get() 의 문제:

submit() — 비동기 (좋음)
  ↓
다른 일 (잠깐)
  ↓
future.get() — ★ 블로킹!
  ↓
스레드 대기 (비동기 무의미)

핵심:
  - get() 에서 블로킹
  - 그 스레드는 대기 점유
  - 비동기 했지만 결국 블록

6.3 시각화

Async + Blocking:
  submit ──→ [작업 진행]
  다른일 (짧게)
  get() ──→ [대기────────]  ← 여기서 블로킹
  결과

  → 작업 시간만큼 결국 대기

Async + Non-Blocking:
  supplyAsync ──→ [작업 진행]
  계속 진행 ──────────────→ (대기 X)
  [작업 완료] ──→ 콜백

  → 진짜 비동기 (대기 X)

6.4 비교

// "가짜 비동기" — Async + Blocking
public Shipment fakeAsync(Long id) throws Exception {
    Future<Shipment> future = executor.submit(() -> repository.findById(id));
    // 비동기 시작
    return future.get();   // ★ 결국 블로킹
    // 이 스레드는 작업 완료까지 대기
    // 비동기 이점 없음
}

// "진짜 비동기" — Async + Non-Blocking
public CompletableFuture<Shipment> realAsync(Long id) {
    return CompletableFuture.supplyAsync(() -> repository.findById(id));
    // 비동기 + 콜백
    // 이 스레드는 대기 X
    // 호출자도 즉시 반환받음
}

6.5 진정한 비동기의 조건

진정한 비동기:

1. 작업 비동기 시작 (백그라운드)
2. 결과도 논블로킹 (콜백/이벤트)
3. 호출 스레드가 대기 X

= Async + Non-Blocking

Future.get() 은:
  - 1번은 만족 (비동기 시작)
  - 2번 위반 (블로킹 회수)
  - → 진정한 비동기 X

6.6 언제 Async + Blocking 도 유용

Async + Blocking 의 유용한 경우:

  여러 작업 동시 시작 후 모두 get:
    - 순차 블로킹보다 빠름
    - 단, get 은 여전히 블로킹

  예:
    Future f1 = submit(task1);
    Future f2 = submit(task2);
    // 동시 시작
    r1 = f1.get();   // 블로킹
    r2 = f2.get();   // 블로킹
    // 순차 (task1 + task2) 보다 빠름 (max)

  하지만 진짜 비동기는 아님

6.7 ILIC 의 맥락

public class TrueVsFakeAsync {
    
    // 가짜 비동기 (Async + Blocking)
    public List<Shipment> fakeAsync(List<Long> ids) throws Exception {
        List<Future<Shipment>> futures = ids.stream()
            .map(id -> executor.submit(() -> repository.findById(id)))
            .toList();   // 동시 시작 (좋음)
        
        return futures.stream()
            .map(f -> {
                try { return f.get(); }   // ★ 블로킹
                catch (Exception e) { throw new RuntimeException(e); }
            })
            .toList();
        // 동시 시작 덕에 빠르나, get 은 블로킹
    }
    
    // 진짜 비동기 (Async + Non-Blocking)
    public CompletableFuture<List<Shipment>> realAsync(List<Long> ids) {
        List<CompletableFuture<Shipment>> futures = ids.stream()
            .map(id -> CompletableFuture.supplyAsync(() -> repository.findById(id)))
            .toList();
        
        return CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
            .thenApply(v -> futures.stream().map(CompletableFuture::join).toList());
        // 완전 논블로킹
        // 호출 스레드 대기 X
    }
}

6.8 자기 점검 답변

"Async + Blocking 이 진정한 비동기가 아니다" 의 의미는?

답:
1. 의미:

작업은 비동기 시작
결과 회수 (get) 가 블로킹
결국 대기

왜:
- future.get() 에서 블록
- 스레드 대기 점유
- 비동기 이점 상실
진정한 비동기:
- 작업 + 결과 모두 논블로킹
- = Async + Non-Blocking
유용한 경우:
- 여러 작업 동시 시작
- 순차보다 빠름 (단 블로킹)

7️⃣ 실무 권장 조합

7.1 권장 — Async + Non-Blocking

실무 가장 권장: Async + Non-Blocking

이유:
  1. 스레드 효율
     - 적은 스레드로 많은 작업
     - 대기 없음

  2. 처리량 ↑
     - 높은 동시성
     - C10K 해결

  3. 응답성 ↑
     - 콜백
     - 빠른 응답

단, 복잡도 ↑

7.2 상황별 권장

상황별 권장 조합:

단순 앱 + 적은 동시성:
  → Sync + Blocking (단순함)

높은 동시성 + I/O 바운드:
  → Async + Non-Blocking (효율)

여러 작업 병렬 + 단순함:
  → Async + Blocking (Future.get)
  (진짜 비동기 아니지만 충분)

레거시 + 점진적 개선:
  → Virtual Thread (Java 21+)
  블로킹 코드 + 효율

7.3 Virtual Thread 의 등장

Virtual Thread (Java 21+):

  Sync + Blocking 코드를
  Async + Non-Blocking 효율로.

원리:
  - 블로킹 작업 시 OS 스레드 양보
  - 가상 스레드는 경량
  - 수만 개 가능

장점:
  - 단순한 블로킹 코드
  - 높은 효율
  - 복잡도 ↓

→ 4분면의 트레이드오프 완화

7.4 Virtual Thread 예시

// Virtual Thread — 단순 코드 + 효율
public void virtualThreadExample(List<Long> ids) {
    try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
        for (Long id : ids) {
            executor.submit(() -> {
                // Sync + Blocking 코드 (단순)
                Shipment s = repository.findById(id);   // 블로킹
                // 하지만 가상 스레드는 I/O 시 양보
                // → Async + Non-Blocking 효율
                process(s);
            });
        }
    }
    // 수만 작업도 OK
    // 블로킹 코드 + 비동기 효율
}

7.5 선택 가이드

선택 가이드:

성능 vs 복잡도:

Sync + Blocking:
  - 복잡도 ★
  - 효율 ★
  - 대부분의 경우 (적은 동시성)

Async + Non-Blocking:
  - 복잡도 ★★★★★
  - 효율 ★★★★★
  - 높은 동시성 필수

Virtual Thread (Java 21+):
  - 복잡도 ★ (블로킹 코드)
  - 효율 ★★★★ (자동 최적화)
  - 권장 (현대)

7.6 ILIC 의 선택

@Service
public class ShipmentServiceModern {
    
    // 일반 처리 — Sync + Blocking (단순)
    public Shipment getSimple(Long id) {
        return repository.findById(id);
        // 대부분의 CRUD
    }
    
    // 높은 동시성 — Async + Non-Blocking
    public CompletableFuture<List<Shipment>> getManyAsync(List<Long> ids) {
        List<CompletableFuture<Shipment>> futures = ids.stream()
            .map(id -> CompletableFuture.supplyAsync(() -> repository.findById(id)))
            .toList();
        return CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
            .thenApply(v -> futures.stream().map(CompletableFuture::join).toList());
    }
    
    // 현대 — Virtual Thread (단순 + 효율)
    public List<Shipment> getManyVirtual(List<Long> ids) {
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            List<Future<Shipment>> futures = ids.stream()
                .map(id -> executor.submit(() -> repository.findById(id)))
                .toList();
            return futures.stream().map(this::getResult).toList();
        }
        // 블로킹 코드지만 효율적
    }
    
    private Shipment getResult(Future<Shipment> f) {
        try { return f.get(); } catch (Exception e) { throw new RuntimeException(e); }
    }
}

7.7 자기 점검 답변

실무 권장 조합은?

답:
1. 가장 권장:

Async + Non-Blocking
효율, 처리량
단 복잡

상황별:
- 단순: Sync + Blocking
- 높은 동시성: Async + Non-Blocking
- 병렬: Async + Blocking
Virtual Thread:
- 블로킹 코드 + 효율
- 복잡도 ↓
- 현대 권장
트레이드오프:
- 성능 vs 복잡도
- Virtual Thread 가 완화

8️⃣ Phase 2 완주 정리

8.1 Phase 2 학습 종합

Phase 2 — Sync/Async × Blocking/Non-Blocking 4분면

Unit 2.1 — Sync vs Async (작업 순서)
  - 동기: 완료 확인 후
  - 비동기: 통보 (콜백)
  - Latency vs Throughput

Unit 2.2 — Blocking vs Non-Blocking (제어권)
  - 블로킹: 제어권 잃고 대기
  - 논블로킹: 제어권 유지
  - polling, callback

Unit 2.3 — 4분면 매트릭스 (★ 마스터)
  - 4가지 조합
  - Sync+Blocking ~ Async+Non-Blocking
  - 진정한 비동기
  - 실무 권장

8.2 두 축의 정리

두 개의 독립 축:

축 1: Sync/Async (작업 순서)
  - 완료를 확인하고 다음?
  - 결과를 언제 받나

축 2: Blocking/Non-Blocking (제어권)
  - 호출 시 대기?
  - 제어권 가져갔나

4가지 조합:
  - 두 축은 독립
  - 모든 조합 가능

8.3 4분면 핵심 정리

4분면 핵심:

Sync + Blocking:
  - 전통 IO, 단순, 비효율

Sync + Non-Blocking:
  - NIO Polling, 제어권 유지

Async + Blocking:
  - Future.get, "가짜 비동기"

Async + Non-Blocking:
  - CompletableFuture, 최고 효율

8.4 다음 Phase 예고

Phase 2 → Phase 3:
  - 개념 → 실전 스레드

Phase 3 — 스레드 만들고 다루기:
  - 스레드 상태
  - Thread/Runnable
  - 데몬
  - join()

8.5 4주차 누적 진행

✅ Phase 1 — 동시성의 기초 (4 Unit)
✅ Phase 2 — 4분면 매트릭스 (3 Unit) ← 완주
⏭ Phase 3 — 스레드 다루기 (5 Unit)
⏭ Phase 4 — synchronized & volatile (5 Unit)
⏭ Phase 5 — Lock 도구 (4 Unit)
⏭ Phase 6 — 스레드 협력 (4 Unit)
⏭ Phase 7 — Executor (7 Unit)
⏭ Phase 8 — 고급 비동기 (3 Unit)

총: 7/35 Unit (Phase 2 완주, 약 20%)

8.6 자기 점검 답변

Phase 2 의 종합은?

답:
1. 3개 Unit:

Sync/Async (작업 순서)
Blocking/Non-Blocking (제어권)
4분면 매트릭스

두 축:
- 독립적
- 4가지 조합
4분면:
- Sync+Blocking (전통)
- Async+Non-Blocking (효율)
핵심:
- 진정한 비동기 = Async+Non-Blocking
- 실무: Virtual Thread 도

9️⃣ 면접 + 자기 점검 + Phase 2 졸업 시험

9.1 면접 단골 질문 매핑

Q	핵심 답변
4분면 두 축?	Sync/Async, Blocking/Non-Blocking
Sync + Blocking?	전통 IO, 단순, 비효율
Sync + Non-Blocking?	NIO Polling
Async + Blocking?	Future.get (가짜 비동기)
Async + Non-Blocking?	CompletableFuture (효율)
진짜 비동기?	Async + Non-Blocking
왜 Future.get 가짜?	결과 회수 블로킹
실무 권장?	Async + Non-Blocking
Virtual Thread?	블로킹 코드 + 효율
두 축 독립?	4가지 조합 가능

9.2 Phase 2 졸업 시험 50문항

Sync/Async (15문항)

Q1. 동기? → 완료 확인 후 다음
Q2. 비동기? → 완료 안 기다림, 통보
Q3. 판단 기준? → 작업 순서/완료 확인
Q4. 핵심 질문? → 완료 여부 확인?
Q5. 동기 장점? → 단순, 직관
Q6. 비동기 장점? → 처리량
Q7. DB 비동기? → 결과 안 기다림
Q8. 비동기 항상 빠른가? → 아니다
Q9. Latency? → 단일 작업 시간
Q10. Throughput? → 처리량
Q11. 비동기는 무엇 개선? → Throughput
Q12. 콜백? → 완료 시 호출
Q13. 콜백 지옥? → 중첩, 체이닝 해결
Q14. Future? → 미래 결과
Q15. CompletableFuture? → 콜백 + 체이닝

Blocking/Non-Blocking (15문항)

Q16. 블로킹? → 제어권 잃고 대기
Q17. 논블로킹? → 즉시 제어권 반환
Q18. 제어권? → 실행 흐름 권리
Q19. 판단 기준? → 제어권 가져갔나
Q20. 블로킹 예? → Socket.read, lock
Q21. 논블로킹 예? → NIO, CompletableFuture
Q22. Sync vs Blocking? → 순서 vs 제어권
Q23. 논블로킹 결과? → polling, callback
Q24. Polling? → 반복 확인
Q25. Polling 문제? → busy waiting
Q26. Selector? → 1 스레드 여러 채널
Q27. 블로킹 I/O 상태? → RUNNABLE(자바)
Q28. 락 블로킹 상태? → BLOCKED
Q29. NIO? → Channel/Buffer/Selector
Q30. C10K? → 1만 연결, 논블로킹 해결

4분면 (20문항)

Q31. 4분면 축? → Sync/Async × Block/NonBlock
Q32. Sync+Blocking? → 전통 IO
Q33. Sync+NonBlocking? → NIO Polling
Q34. Async+Blocking? → Future.get
Q35. Async+NonBlocking? → CompletableFuture
Q36. 가장 단순? → Sync+Blocking
Q37. 가장 효율? → Async+NonBlocking
Q38. 진짜 비동기? → Async+NonBlocking
Q39. 왜 Future.get 가짜? → 회수 블로킹
Q40. Socket.read 조합? → Sync+Blocking
Q41. channel.read==0? → Sync+NonBlocking
Q42. thenAccept? → Async+NonBlocking
Q43. 실무 권장? → Async+NonBlocking
Q44. 두 축 독립? → 4조합 가능
Q45. Sync+Blocking 단점? → 스레드 대기
Q46. Async+NonBlocking 단점? → 복잡
Q47. Virtual Thread? → 블로킹 코드 + 효율
Q48. 효율 순서? → Sync+Block < Async+NonBlock
Q49. 복잡도 순서? → 반대
Q50. CompletableFuture 메서드? → thenApply/Compose/Combine

9.3 채점

50 / 50 → Phase 2 마스터
45-49   → 거의 마스터
40-44   → 복습
< 40    → Unit 2.1 ~ 2.3 재학습

9.4 추가 심화 질문

Q1: 톰캣은 어떤 조합?

답:

전통 Spring MVC: Sync + Blocking
스레드 풀 (요청당 스레드)
WebFlux: Async + Non-Blocking
Netty 기반

Q2: Node.js 의 모델?

답:

이벤트 루프 (단일 스레드)
Async + Non-Blocking
논블로킹 I/O
콜백/Promise/async-await

Q3: Reactive Streams?

답:

비동기 + 백프레셔
Publisher-Subscriber
Flux/Mono (Reactor)
Async + Non-Blocking + 흐름 제어

Q4: 블로킹 코드를 WebFlux 에서?

답:

위험 (이벤트 루프 블록)
subscribeOn(boundedElastic())
별도 스레드로
또는 처음부터 논블로킹

Q5: 4분면을 실생활로?

답:

Sync+Blocking: 전화 걸고 기다림
Sync+NonBlocking: 가끔 확인
Async+Blocking: 맡기고 결국 대기
Async+NonBlocking: 맡기고 통보받음

🎯 핵심 요약 — 3줄 정리

1. 4분면 매트릭스

두 축: Sync/Async × Blocking/Non-Blocking
독립적 → 4가지 조합

2. 4가지

Sync+Blocking (전통), Sync+NonBlocking (Polling)
Async+Blocking (Future.get, 가짜), Async+NonBlocking (CompletableFuture)

3. 실무

권장: Async + Non-Blocking (효율)
Virtual Thread: 블로킹 코드 + 효율

🏆 Phase 2 완주 — 4분면 매트릭스 마스터

🚀 Phase 2 — Sync/Async × Blocking/Non-Blocking 4분면
  ✅ Unit 2.1 Sync vs Async (작업 순서)
  ✅ Unit 2.2 Blocking vs Non-Blocking (제어권)
  ✅ Unit 2.3 4분면 매트릭스 (★ 마스터) ← 여기, Phase 2 완주

→ 두 축 (작업 순서 + 제어권)
→ 4가지 조합
→ 진정한 비동기 = Async+NonBlocking

📚 다음으로...

Phase 3 — 스레드 만들고 다루기

Phase 3 — 스레드 만들고 다루기 (5 Unit)

Unit 3.1 — 스레드 상태 다이어그램
Unit 3.2 — Thread 클래스 상속
Unit 3.3 — Runnable 인터페이스
Unit 3.4 — 데몬 스레드
Unit 3.5 — join()

4주차 누적 진행

✅ Phase 1 — 동시성의 기초 (4 Unit)
✅ Phase 2 — 4분면 매트릭스 (3 Unit)
⏭ Phase 3 — 스레드 다루기 (5 Unit)

총: 7/35 Unit (약 20%)

4주차 Unit 2.3 — 4분면 매트릭스 (실전 예제)

댓글