Unit 3.3 — Runnable 인터페이스 (왜 더 좋은가)
F-LAB JAVA · 4주차 · Phase 3 · 스레드 만들고 다루기
📌 학습 목표
이 Unit을 끝내면 다음을 답할 수 있어야 한다.
- Runnable 인터페이스 의 정의와 구조는?
- Thread 상속의 한계 (단일 상속, 결합) 는?
- Runnable 의 장점 3가지 는?
- 람다로 Runnable 을 만들 수 있는 이유는?
- 같은 Runnable 을 여러 스레드 가 공유하면?
- 작업과 스레드의 분리 의 의미는?
- Spring @Async 는 내부적으로 무엇을 쓰나?
- Runnable vs Callable 의 차이는?
- Thread 상속 vs Runnable 구현 의 선택은?
🎯 핵심 한 문장
Runnable 은 단 하나의 추상 메서드
run()을 가진 함수형 인터페이스로, Thread 에 작업을 전달하는 방식이며, Thread 상속보다 권장된다.
Thread 상속의 한계 — 자바는 단일 상속만 가능하여 다른 클래스를 상속할 수 없고, 작업과 스레드 제어가 결합된다.
Runnable 의 장점 3가지 — (1) 다른 클래스 상속 가능 (인터페이스라 다중 구현), (2) 작업과 스레드 분리 (객체지향적 설계), (3) 메모리 효율 (여러 스레드가 같은 Runnable 공유 가능).
Runnable 은 함수형 인터페이스 (SAM) 이므로 람다로 간결하게 작성할 수 있다 (() -> {...}).
Spring 의@Async는 내부적으로 작업을 Runnable (또는 Callable) 로 감싸 ThreadPoolTaskExecutor 에 제출한다 — Runnable 기반.
비유 — 일(task)과 일꾼(worker) 분리
Thread 상속 = 일꾼이 일을 내장:
class 청소일꾼 extends 일꾼 {
void 일() { 청소하기 }
}
- 일꾼 = 청소만 하는 일꾼
- 다른 일 시키려면 새 클래스
Runnable = 일(작업서)과 일꾼 분리:
Runnable 청소 = () -> 청소하기;
Runnable 요리 = () -> 요리하기;
일꾼(Thread)에게 작업서 전달:
new 일꾼(청소).start();
new 일꾼(요리).start();
- 일꾼은 범용
- 작업서만 바꿈
- 같은 작업서를 여러 일꾼이 (공유)
장점:
- 일꾼 재사용
- 작업 교체 쉬움
- 일꾼이 다른 역할도 (상속)→ Runnable = 작업서, Thread = 일꾼, 분리가 핵심.
🧭 9개 섹션 로드맵
1. Runnable 인터페이스의 정의
2. Thread 상속의 한계
3. 장점 1 — 다른 클래스 상속 가능
4. 장점 2 — 작업과 스레드 분리
5. 장점 3 — 메모리 효율 (공유)
6. 람다로 Runnable
7. Spring @Async의 내부
8. Runnable vs Callable, 선택 가이드
9. 면접 + 자기 점검1️⃣ Runnable 인터페이스의 정의
1.1 Runnable 인터페이스
@FunctionalInterface
public interface Runnable {
void run(); // 단 하나의 추상 메서드 (SAM)
}핵심:
- 함수형 인터페이스 (SAM)
run()메서드 하나- 스레드가 실행할 작업
1.2 사용 방법
// 1. 클래스로 구현
class MyTask implements Runnable {
@Override
public void run() {
System.out.println("Task running");
}
}
Thread t = new Thread(new MyTask());
t.start();
// 2. 람다 (함수형 인터페이스)
Runnable task = () -> System.out.println("Lambda task");
Thread t2 = new Thread(task);
t2.start();
// 3. 익명 클래스
Thread t3 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("Anonymous task");
}
});
t3.start();1.3 Thread 와 Runnable 의 관계
// Thread 도 Runnable 구현
public class Thread implements Runnable {
private Runnable target; // 전달받은 Runnable
public Thread(Runnable target) {
this.target = target;
}
@Override
public void run() {
if (target != null) {
target.run(); // Runnable 실행
}
}
}1.4 두 가지 방식 비교
// 방식 1: Thread 상속
class MyThread extends Thread {
@Override
public void run() { doWork(); }
}
new MyThread().start();
// 방식 2: Runnable 구현 (권장)
class MyTask implements Runnable {
@Override
public void run() { doWork(); }
}
new Thread(new MyTask()).start();1.5 ILIC 의 맥락
// Runnable 구현
public class ShipmentTask implements Runnable {
private final Shipment shipment;
private final ShipmentService service;
public ShipmentTask(Shipment shipment, ShipmentService service) {
this.shipment = shipment;
this.service = service;
}
@Override
public void run() {
service.process(shipment);
}
}
// 사용
Runnable task = new ShipmentTask(shipment, service);
new Thread(task).start();
// 또는 람다
new Thread(() -> service.process(shipment)).start();1.6 자기 점검 답변
Runnable 인터페이스의 정의는?
답:
1. 정의:
- 함수형 인터페이스 (SAM)
- run() 메서드 하나
-
사용:
- 클래스 구현
- 람다
- 익명 클래스
-
Thread 와 관계:
- Thread 가 Runnable 구현
- target 으로 받음
-
방식:
- new Thread(runnable).start()
2️⃣ Thread 상속의 한계
2.1 두 가지 한계
Thread 상속의 한계:
1. 단일 상속 제약
- 자바는 단일 상속
- Thread 상속 시 다른 클래스 X
2. 작업과 제어 결합
- 작업 (run) 과 스레드 제어 섞임
- 객체지향적 X
- 재사용 어려움2.2 단일 상속 제약
// ❌ Thread 상속 + 다른 클래스 상속 불가
class BaseProcessor {
protected void log(String msg) { }
}
class ShipmentProcessor extends BaseProcessor { // 이미 상속
// extends Thread 불가!
// 자바는 단일 상속
}
// 해결: Runnable 구현
class ShipmentProcessor extends BaseProcessor
implements Runnable { // 인터페이스 추가 (다중 가능)
@Override
public void run() {
log("Processing"); // BaseProcessor 메서드 활용
}
}2.3 작업과 제어의 결합
// Thread 상속 — 작업 + 제어 결합
class ShipmentThread extends Thread {
// 스레드 제어 (Thread 의 것)
// + 작업 (run)
// 섞여 있음
@Override
public void run() {
// 작업
}
}
// 문제:
// - 작업만 따로 쓰기 어려움
// - 스레드 없이 작업 실행 X
// - 테스트 어려움2.4 재사용의 어려움
// Thread 상속 — 작업 재사용 어려움
class MyThread extends Thread {
@Override
public void run() { doWork(); }
}
// 같은 작업을 여러 스레드가?
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
// 각각 별도 인스턴스 (작업 정의 중복)
// Runnable — 작업 공유
Runnable task = () -> doWork();
new Thread(task).start();
new Thread(task).start(); // 같은 작업 공유2.5 시각화
Thread 상속:
┌─────────────────┐
│ MyThread │
│ - 스레드 제어 │ ← Thread 의 기능
│ - run() 작업 │ ← 작업
│ (결합) │
└─────────────────┘
단일 상속 (다른 클래스 X)
Runnable 구현:
┌──────────┐ ┌──────────┐
│ Thread │ ── │ Runnable │
│ (제어) │ │ (작업) │
└──────────┘ └──────────┘
분리 (다른 클래스 상속 가능)2.6 ILIC 의 맥락
// ❌ Thread 상속의 한계
public class ShipmentThreadBad extends Thread {
// BaseService 상속 불가 (이미 Thread)
// 작업 + 제어 결합
@Override
public void run() {
// process()...
}
}
// ✓ Runnable — 한계 극복
public class ShipmentTaskGood extends BaseService
implements Runnable { // 다른 클래스 + Runnable
@Override
public void run() {
// BaseService 의 메서드 활용
process(); // 상속 메서드
}
}2.7 자기 점검 답변
Thread 상속의 한계는?
답:
1. 단일 상속:
- 자바 단일 상속
- Thread 상속 시 다른 클래스 X
-
작업 + 제어 결합:
- run 과 스레드 제어 섞임
- 객체지향적 X
-
재사용 어려움:
- 작업 분리 X
- 같은 작업 공유 어려움
-
해결:
- Runnable 구현
3️⃣ 장점 1 — 다른 클래스 상속 가능
3.1 인터페이스의 다중 구현
Runnable 의 장점 1:
Runnable 은 인터페이스.
- 클래스는 다른 클래스 상속 가능
- + Runnable 인터페이스 구현
- 다중 인터페이스도 가능
자바:
- 클래스 단일 상속
- 인터페이스 다중 구현3.2 예시
// 다른 클래스 상속 + Runnable
class ShipmentProcessor extends BaseProcessor // 클래스 상속
implements Runnable, Comparable<ShipmentProcessor> { // 다중 인터페이스
@Override
public void run() {
// 작업
}
@Override
public int compareTo(ShipmentProcessor o) {
return 0;
}
}
// Thread 상속으로는 불가능3.3 기존 클래스에 Runnable 추가
// 기존 클래스
class ExistingService {
public void doBusinessLogic() { }
}
// Runnable 추가 (상속 유지)
class ExistingServiceTask extends ExistingService
implements Runnable {
@Override
public void run() {
doBusinessLogic(); // 기존 메서드 활용
}
}
// 기존 코드 변경 없이 스레드화3.4 프레임워크 클래스 상속
// Spring 의 클래스 상속 + Runnable
class ScheduledTask extends AbstractTask // 프레임워크 클래스
implements Runnable {
@Override
public void run() {
// 스케줄 작업
}
}
// AbstractTask 상속 유지
// + 스레드로 실행 가능3.5 ILIC 의 맥락
// 기존 서비스 + Runnable
@Service
public class ShipmentService extends AbstractAuditableService {
// AbstractAuditableService 상속 (감사 로그 등)
public void process(Shipment s) {
audit("Processing " + s.getId()); // 상속 메서드
// 처리
}
}
// 스레드화 — Runnable 구현 별도 클래스
public class ShipmentProcessTask implements Runnable {
private final ShipmentService service;
private final Shipment shipment;
@Override
public void run() {
service.process(shipment);
}
}
// 또는 람다
Runnable task = () -> service.process(shipment);3.6 자기 점검 답변
장점 1 — 다른 클래스 상속 가능은?
답:
1. 인터페이스 다중:
- 클래스 상속 + Runnable
- 다중 인터페이스
-
예시:
- extends Base implements Runnable
- Thread 로는 불가
-
활용:
- 기존 클래스에 Runnable 추가
- 프레임워크 클래스 상속 유지
-
이유:
- 자바 단일 상속 회피
4️⃣ 장점 2 — 작업과 스레드 분리
4.1 관심사 분리
Runnable 의 장점 2:
작업 (Runnable) 과 스레드 제어 (Thread) 를
분리.
효과:
- 객체지향적 설계
- 작업 단독 사용 가능
- 테스트 쉬움
- 유연성4.2 작업 단독 사용
// Runnable — 작업 단독 사용 가능
Runnable task = () -> processShipment();
// 1. 스레드로 실행
new Thread(task).start();
// 2. 직접 실행 (테스트 등)
task.run(); // 현재 스레드
// 3. Executor 에 제출
executor.submit(task);
// 4. 다른 곳에 전달
scheduleService.schedule(task);
// 같은 작업, 여러 실행 방식4.3 테스트 용이성
// Runnable — 테스트 쉬움
public class ShipmentTask implements Runnable {
@Override
public void run() {
process();
}
void process() {
// 작업
}
}
// 테스트 — 스레드 없이
@Test
void testProcess() {
ShipmentTask task = new ShipmentTask();
task.run(); // 직접 호출 (스레드 X)
// 결과 검증
}
// Thread 상속이면 스레드 띄워야 (테스트 복잡)4.4 실행 방식 교체
// 작업 정의 (Runnable)
Runnable task = () -> processData();
// 실행 방식 자유롭게 교체
// 1. 단순 스레드
new Thread(task).start();
// 2. 스레드 풀
executor.submit(task);
// 3. 스케줄러
scheduledExecutor.scheduleAtFixedRate(task, 0, 1, SECONDS);
// 4. 비동기
CompletableFuture.runAsync(task);
// 작업은 그대로, 실행만 변경4.5 시각화
작업과 스레드 분리:
작업 (Runnable):
┌──────────────┐
│ run() { ... } │
└──────┬───────┘
│ 다양한 실행
┌────┼────┬────────┐
↓ ↓ ↓ ↓
Thread Executor 스케줄러 CompletableFuture
하나의 작업, 여러 실행4.6 ILIC 의 맥락
@Service
public class ShipmentExecutionService {
private final ExecutorService executor;
private final ScheduledExecutorService scheduler;
// 작업 정의 (Runnable)
private Runnable createTask(Shipment shipment) {
return () -> shipmentService.process(shipment);
}
// 1. 즉시 실행 (스레드 풀)
public void processNow(Shipment shipment) {
executor.submit(createTask(shipment));
}
// 2. 지연 실행 (스케줄러)
public void processLater(Shipment shipment, long delaySeconds) {
scheduler.schedule(createTask(shipment), delaySeconds, TimeUnit.SECONDS);
}
// 3. 비동기
public CompletableFuture<Void> processAsync(Shipment shipment) {
return CompletableFuture.runAsync(createTask(shipment), executor);
}
// 같은 작업 정의, 다양한 실행
}4.7 자기 점검 답변
장점 2 — 작업과 스레드 분리는?
답:
1. 관심사 분리:
- 작업 (Runnable)
- 제어 (Thread)
-
효과:
- 작업 단독 사용
- 테스트 쉬움
- 유연성
-
실행 방식:
- Thread, Executor
- 스케줄러, CompletableFuture
- 교체 자유
-
객체지향:
- 책임 분리
5️⃣ 장점 3 — 메모리 효율 (공유)
5.1 같은 Runnable 공유
Runnable 의 장점 3:
하나의 Runnable 인스턴스를
여러 스레드가 공유 가능.
효과:
- 메모리 효율
- 작업 정의 한 번
- 여러 스레드 같은 작업5.2 공유 예시
// 하나의 Runnable
Runnable task = () -> processShipments();
// 여러 스레드가 공유
Thread t1 = new Thread(task);
Thread t2 = new Thread(task);
Thread t3 = new Thread(task);
// 같은 task 인스턴스 (메모리 1개)
t1.start();
t2.start();
t3.start();
// 3 스레드가 같은 작업 실행5.3 Thread 상속과 비교
// Thread 상속 — 각각 인스턴스
class MyThread extends Thread {
@Override
public void run() { doWork(); }
}
MyThread t1 = new MyThread(); // 인스턴스 1
MyThread t2 = new MyThread(); // 인스턴스 2
MyThread t3 = new MyThread(); // 인스턴스 3
// 작업 정의가 각 인스턴스에
// Runnable — 작업 공유
Runnable task = () -> doWork(); // 작업 1개
new Thread(task); // 공유
new Thread(task); // 공유
new Thread(task); // 공유5.4 공유 시 주의 — 상태
// 공유 Runnable 의 상태 주의
class CounterTask implements Runnable {
private int count = 0; // ★ 공유 상태!
@Override
public void run() {
count++; // 여러 스레드 동시 → 위험
}
}
// 같은 인스턴스 공유
CounterTask task = new CounterTask();
new Thread(task).start();
new Thread(task).start();
// count 동시 수정 → 데이터 손실
// 무상태 Runnable 권장
Runnable stateless = () -> {
int local = 0; // 지역 변수 (안전)
local++;
};5.5 시각화
Runnable 공유:
Runnable task (메모리 1개)
↑ ↑ ↑
│ │ │
Thread1 Thread2 Thread3
(각자 실행)
작업 정의 1개, 스레드 여러 개
Thread 상속:
MyThread1 MyThread2 MyThread3
(각자 작업 내장)
메모리 3개5.6 ILIC 의 맥락
public class SharedTaskExample {
// 무상태 작업 (공유 안전)
public void processWithSharedTask(List<Shipment> shipments) {
// 작업 정의 (무상태)
Runnable healthCheck = () -> {
log.info("Health check on {}", Thread.currentThread().getName());
checkSystemHealth();
};
// 여러 스레드가 같은 작업
for (int i = 0; i < 5; i++) {
new Thread(healthCheck).start(); // 공유
}
// healthCheck 인스턴스 1개
// 5 스레드가 공유 (안전 — 무상태)
}
// 상태 있는 작업 (스레드별 인스턴스 또는 동기화)
public void processWithState(List<Shipment> shipments) {
for (Shipment s : shipments) {
// 각 스레드마다 별도 (상태 격리)
Runnable task = () -> process(s); // s 캡처
new Thread(task).start();
}
}
private void checkSystemHealth() { }
private void process(Shipment s) { }
}5.7 자기 점검 답변
장점 3 — 메모리 효율은?
답:
1. 공유:
- 하나의 Runnable
- 여러 스레드
-
효과:
- 메모리 효율
- 작업 정의 한 번
-
vs Thread 상속:
- Thread: 각 인스턴스
- Runnable: 공유
-
주의:
- 공유 상태 위험
- 무상태 권장
6️⃣ 람다로 Runnable
6.1 함수형 인터페이스
Runnable 은 함수형 인터페이스:
@FunctionalInterface
interface Runnable {
void run(); // SAM
}
→ 람다로 작성 가능6.2 람다 표현
// 익명 클래스 (옛)
Runnable task1 = new Runnable() {
@Override
public void run() {
System.out.println("Hello");
}
};
// 람다 (Java 8+)
Runnable task2 = () -> System.out.println("Hello");
// 훨씬 간결
// 여러 줄
Runnable task3 = () -> {
System.out.println("Line 1");
System.out.println("Line 2");
};6.3 Thread 에 람다
// Thread 에 직접 람다
new Thread(() -> {
processShipment();
}).start();
// 메서드 참조
new Thread(this::processShipment).start();
// 간결, 가독성6.4 왜 람다 가능한가
람다가 가능한 이유:
Runnable 이 SAM (Single Abstract Method).
- 추상 메서드 1개 (run)
- 컴파일러가 람다 → run() 매핑
() -> {...}
→ run() 의 구현으로 해석6.5 람다 vs 익명 클래스
// 익명 클래스
Runnable r1 = new Runnable() {
@Override
public void run() { doWork(); }
};
// 람다 (더 간결)
Runnable r2 = () -> doWork();
// 차이:
// - 람다: 간결, this 는 외부
// - 익명: 길음, this 는 자신
// (3주차 Phase 10 람다 참고)6.6 ILIC 의 맥락
public class LambdaRunnableExample {
private final ShipmentService service;
public void variousLambdas(Shipment shipment) {
// 1. 간단한 람다
new Thread(() -> service.process(shipment)).start();
// 2. 메서드 참조
Runnable healthCheck = this::checkHealth;
new Thread(healthCheck).start();
// 3. 여러 줄
new Thread(() -> {
log.info("Start processing {}", shipment.getId());
service.process(shipment);
log.info("Done");
}).start();
// 4. Executor 와 함께
executor.submit(() -> service.process(shipment));
// 5. CompletableFuture
CompletableFuture.runAsync(() -> service.process(shipment));
}
private void checkHealth() { }
}6.7 자기 점검 답변
람다로 Runnable을 만들 수 있는 이유는?
답:
1. 함수형 인터페이스:
- SAM (run 하나)
- 람다 가능
-
표현:
- () -> {...}
- 메서드 참조
-
이유:
- 추상 메서드 1개
- 컴파일러 매핑
-
장점:
- 간결
- 가독성
7️⃣ Spring @Async의 내부
7.1 @Async 의 동작
Spring @Async:
메서드를 비동기로 실행.
내부적으로 작업을 TaskExecutor 에 제출.
동작:
1. @Async 메서드 호출
2. Spring 프록시가 가로챔
3. 작업을 Runnable/Callable 로 감쌈
4. TaskExecutor 에 제출
5. 별도 스레드에서 실행7.2 @Async 예시
@Service
public class ShipmentAsyncService {
@Async
public void processAsync(Shipment shipment) {
// 별도 스레드에서 실행
service.process(shipment);
}
@Async
public CompletableFuture<Result> processWithResult(Shipment shipment) {
Result result = service.process(shipment);
return CompletableFuture.completedFuture(result);
}
}
// 호출
shipmentAsyncService.processAsync(shipment);
// 즉시 반환 (별도 스레드에서 처리)7.3 내부 — Runnable/Callable
@Async 의 내부:
void 반환:
- 작업을 Runnable 로 감쌈
- taskExecutor.execute(runnable)
CompletableFuture/Future 반환:
- Callable 로 감쌈
- taskExecutor.submit(callable)
핵심:
- Runnable/Callable 기반
- ThreadPoolTaskExecutor 사용7.4 TaskExecutor 설정
@Configuration
@EnableAsync
public class AsyncConfig {
@Bean
public Executor taskExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(4);
executor.setMaxPoolSize(8);
executor.setQueueCapacity(100);
executor.setThreadNamePrefix("async-");
executor.initialize();
return executor;
}
}
// @Async 가 이 executor 사용
// 내부적으로 Runnable/Callable 제출7.5 @Async 의 제약
@Async 의 주의:
1. public 메서드만
- 프록시 기반
2. self-invocation X
- 같은 클래스 내부 호출 시 비동기 X
- 프록시 우회
3. 반환 타입
- void
- Future / CompletableFuture
4. 예외 처리
- void: AsyncUncaughtExceptionHandler
- Future: get() 시 예외7.6 ILIC 의 맥락
@Configuration
@EnableAsync
public class ShipmentAsyncConfig {
@Bean("shipmentExecutor")
public Executor shipmentExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
int cores = Runtime.getRuntime().availableProcessors();
executor.setCorePoolSize(cores);
executor.setMaxPoolSize(cores * 2);
executor.setThreadNamePrefix("shipment-async-");
executor.initialize();
return executor;
}
}
@Service
public class ShipmentNotificationService {
// 비동기 알림 (Runnable 기반)
@Async("shipmentExecutor")
public void sendNotificationAsync(Shipment shipment) {
// 별도 스레드 (executor 의)
// 내부적으로 Runnable 로 감싸짐
emailService.send(shipment.getConsignee(), buildMessage(shipment));
}
// 비동기 + 결과 (Callable 기반)
@Async("shipmentExecutor")
public CompletableFuture<TrackingInfo> fetchTrackingAsync(String blNo) {
TrackingInfo info = trackingApi.fetch(blNo);
return CompletableFuture.completedFuture(info);
}
}7.7 자기 점검 답변
Spring @Async는 내부적으로 무엇을 쓰나?
답:
1. 동작:
- 프록시가 가로챔
- TaskExecutor 에 제출
-
내부:
- void: Runnable
- Future: Callable
-
TaskExecutor:
- ThreadPoolTaskExecutor
- 스레드 풀
-
제약:
- public 메서드
- self-invocation X
- 반환 타입 (void/Future)
8️⃣ Runnable vs Callable, 선택 가이드
8.1 Runnable vs Callable
| 항목 | Runnable | Callable |
|---|---|---|
| 메서드 | void run() | V call() throws Exception |
| 반환값 | ❌ | ✅ (제네릭) |
| 체크 예외 | ❌ | ✅ |
| 도입 | Java 1.0 | Java 5 |
| 사용 | Thread, Executor | Executor (submit) |
8.2 Callable 예시
// Callable — 반환값 + 예외
Callable<Shipment> task = () -> {
Shipment s = repository.findById(1L); // 예외 가능
return s; // 반환값
};
// Executor 에 제출
Future<Shipment> future = executor.submit(task);
Shipment result = future.get(); // 결과 회수
// Runnable 은 반환값 X
Runnable r = () -> {
repository.findById(1L); // 반환 안 됨
// throws 불가
};8.3 언제 Runnable, 언제 Callable
Runnable 사용:
- 반환값 불필요
- 단순 작업
- 부수 효과 (로그, 알림)
Callable 사용:
- 반환값 필요
- 체크 예외 처리
- 결과 회수 (Future)
예:
- 알림 발송: Runnable
- 계산 + 결과: Callable8.4 Thread 상속 vs Runnable 구현
선택 가이드:
Runnable 구현 (권장):
✓ 다른 클래스 상속 필요
✓ 작업과 스레드 분리
✓ 작업 공유
✓ 대부분의 경우
Thread 상속 (드물게):
✓ Thread 기능 확장 필요
✓ 매우 단순한 경우
실무:
- Runnable/Callable + Executor
- Thread 직접 거의 안 씀8.5 현대적 권장
// ❌ 옛 방식 — Thread 직접
new Thread(() -> doWork()).start();
// ✓ 권장 — Executor + Runnable/Callable
ExecutorService executor = Executors.newFixedThreadPool(4);
executor.submit(() -> doWork()); // Runnable
Future<Result> f = executor.submit(() -> compute()); // Callable
// ✓✓ 현대 — Virtual Thread (Java 21+)
try (var ex = Executors.newVirtualThreadPerTaskExecutor()) {
ex.submit(() -> doWork());
}8.6 ILIC 의 맥락
@Service
public class ShipmentTaskService {
private final ExecutorService executor;
// Runnable — 반환값 불필요 (알림)
public void sendNotification(Shipment shipment) {
executor.submit(() -> { // Runnable
emailService.send(shipment);
});
}
// Callable — 반환값 필요 (계산)
public Future<BigDecimal> calculateFreight(Shipment shipment) {
return executor.submit(() -> { // Callable
return freightCalculator.calculate(shipment); // 반환 + 예외
});
}
// CompletableFuture (권장 — Phase 8)
public CompletableFuture<BigDecimal> calculateFreightAsync(Shipment shipment) {
return CompletableFuture.supplyAsync(
() -> freightCalculator.calculate(shipment),
executor);
}
}8.7 자기 점검 답변
Runnable vs Callable, 선택은?
답:
1. Runnable:
- void run()
- 반환값 X
- 체크 예외 X
-
Callable:
- V call() throws Exception
- 반환값 O
- 체크 예외 O
-
선택:
- 반환 불필요: Runnable
- 반환/예외: Callable
-
Thread vs Runnable:
- Runnable 권장
- Executor 와 함께
9️⃣ 면접 + 자기 점검
9.1 면접 단골 질문 매핑
| Q | 핵심 답변 |
|---|---|
| Runnable? | run() 하나 (함수형 인터페이스) |
| Thread 상속 한계? | 단일 상속, 결합 |
| Runnable 장점 3가지? | 상속 가능, 분리, 공유 |
| 람다 가능 이유? | SAM (함수형) |
| 작업 공유? | 하나의 Runnable 여러 스레드 |
| 작업/스레드 분리? | 객체지향, 유연 |
| @Async 내부? | Runnable/Callable + TaskExecutor |
| Runnable vs Callable? | 반환값/예외 유무 |
| Thread vs Runnable 선택? | Runnable 권장 |
| 공유 시 주의? | 상태 (무상태 권장) |
9.2 자기 점검 체크리스트
Runnable
- 정의 (SAM)
- 사용 방법
- Thread 와 관계
Thread 한계
- 단일 상속
- 결합
- 재사용
장점 3가지
- 다른 클래스 상속
- 작업/스레드 분리
- 메모리 효율 (공유)
람다
- 함수형 인터페이스
- 표현
@Async
- 내부 (Runnable/Callable)
- TaskExecutor
- 제약
Callable
- vs Runnable
- 선택
9.3 추가 심화 질문
Q1: Runnable 의 run 이 예외 못 던지는 이유?
답:
- 인터페이스 시그니처: void run() (throws 없음)
- checked exception 못 던짐
- 반환값도 없음
- → Callable 이 대안 (throws Exception, 반환값)
Q2: Thread 도 Runnable?
답:
- Thread implements Runnable
- Thread 도 run() 보유
- Thread(Runnable) 생성자
- 둘 다 가능
Q3: 람다 vs 메서드 참조?
답:
- 람다: () -> doWork()
- 메서드 참조: this::doWork
- 둘 다 Runnable
- 메서드 참조가 더 간결 (단순 호출 시)
Q4: @Async self-invocation 문제?
답:
- 같은 클래스 내부 호출 시 비동기 X
- 프록시 우회 (this 직접 호출)
- 해결: 별도 빈, 또는 self-injection
- AOP 프록시 한계
Q5: ThreadPoolTaskExecutor vs ExecutorService?
답:
- ThreadPoolTaskExecutor: Spring 추상화
- ExecutorService: 자바 표준
- Spring 은 TaskExecutor 인터페이스
- 내부적으로 ThreadPoolExecutor
🎯 핵심 요약 — 3줄 정리
1. Runnable
- 함수형 인터페이스 (run 하나)
- Thread 에 작업 전달
- 람다 가능
2. 장점 3가지
- 다른 클래스 상속 가능
- 작업과 스레드 분리
- 메모리 효율 (공유)
3. 실무
- Runnable 권장 (Thread 상속보다)
- @Async 도 Runnable/Callable 기반
- Executor 와 함께
📚 다음으로...
Unit 3.4 — 데몬 스레드 (Daemon Thread)
이번 Unit에서 Runnable 을 봤다면, 다음은 데몬 스레드.
- 데몬 스레드의 정의
- 일반 스레드 vs 데몬
- setDaemon(true)
- 용도와 주의
Phase 3 진행 상황
🚀 Phase 3 — 스레드 만들고 다루기
✅ 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 — 스레드 다루기 (3/5 진행)
총: 10/35 Unit
Software Developer