Unit 7.2 — IO vs NIO (역사적 진화)
F-LAB JAVA · 3주차 · Phase 7 · I/O 시스템 큰 그림
📌 학습 목표
이 Unit을 끝내면 다음을 답할 수 있어야 한다.
- IO (Java 1.0) 의 핵심 구조와 한계는?
- NIO (Java 1.4) 가 등장한 배경과 해결한 문제는?
- NIO.2 (Java 7) 의 추가 기능은?
- 3 시대 (IO, NIO, NIO.2) 의 4가지 핵심 차이는?
- File 클래스 vs Files 유틸리티 의 결정적 차이는?
- 단방향 vs 양방향 I/O 의 의미와 효과는?
- Blocking vs Non-blocking 의 개요는? (정밀은 Unit 7.4)
- Decorator 패턴 이 IO 에서 어떻게 활용되는가?
- 실무에서 IO/NIO/NIO.2 선택 가이드 는?
🎯 핵심 한 문장
자바 I/O 는 1.0 의 java.io (스트림), 1.4 의 java.nio (채널+버퍼), 7 의 java.nio.file (NIO.2) 로 3 단계 진화했다.
IO 는 스트림 기반, 1바이트씩, 단방향, Blocking 만 으로 25년 전 디자인의 한계가 있었고,
NIO 는 채널 + 버퍼, 블록 단위, 양방향, Non-blocking 가능 으로 대규모 서버에 대응,
NIO.2 는 Path, Files (static), Stream 통합, 비동기 I/O 로 현대적 파일 API 완성.
셋 다 살아있고, 상황에 따라 선택 — 단순한 파일은 NIO.2, 대규모 네트워크는 NIO, 레거시 호환은 IO.
비유 — 우편 시스템의 진화
IO (Java 1.0, 1996) — 옛 우편국
- 편지 한 장씩 처리 (1바이트)
- 보내는 것과 받는 것 따로 (단방향)
- 줄 서서 대기 (Blocking)
- 누군가 줄에 있으면 모두 대기
NIO (Java 1.4, 2002) — 현대 우체국
- 묶음 단위 처리 (Buffer = 블록)
- 한 창구에서 양방향 (Channel)
- 줄 안 서도 됨 (Non-blocking)
- 한 직원이 여러 손님 (Selector)
NIO.2 (Java 7, 2011) — 디지털 우체국
- 파일 시스템 추상화 (Path)
- 한 줄로 모든 작업 (Files static)
- Stream 통합 (Files.lines)
- 비동기 처리 (AsynchronousChannel)→ 3 시대의 진화 = 한계 → 해결.
🧭 9개 섹션 로드맵
1. IO 의 등장과 구조 (Java 1.0)
2. IO 의 5가지 한계
3. NIO 의 등장과 핵심 개념 (Java 1.4)
4. NIO.2 의 등장과 추가 기능 (Java 7)
5. 3 시대 종합 비교
6. File 클래스 vs Files 유틸리티
7. 단방향 vs 양방향, Blocking vs Non-blocking
8. 실무 활용 가이드
9. 면접 + 자기 점검1️⃣ IO 의 등장과 구조 (Java 1.0)
1.1 IO 의 등장
java.io (Java 1.0, 1996):
자바 최초의 I/O API.
당시 표준 디자인:
- C 의 stdio 영향
- 스트림 기반 사고
- 단방향, 1바이트씩
- 모든 I/O 가 Blocking1.2 IO 의 핵심 구조
java.io 의 클래스 계층:
바이트 스트림:
InputStream (추상)
├── FileInputStream
├── ByteArrayInputStream
├── PipedInputStream
├── FilterInputStream
│ ├── BufferedInputStream
│ ├── DataInputStream
│ └── PushbackInputStream
└── ObjectInputStream
OutputStream (추상)
├── FileOutputStream
├── ByteArrayOutputStream
├── PipedOutputStream
├── FilterOutputStream
│ ├── BufferedOutputStream
│ ├── DataOutputStream
│ └── PrintStream
└── ObjectOutputStream
문자 스트림:
Reader (추상)
├── FileReader
├── StringReader
├── CharArrayReader
├── InputStreamReader
└── BufferedReader
Writer (추상)
├── FileWriter
├── StringWriter
├── CharArrayWriter
├── OutputStreamWriter
├── BufferedWriter
└── PrintWriter1.3 바이트 vs 문자 스트림
바이트 스트림 (InputStream, OutputStream):
- 1바이트 단위
- 모든 데이터 (이미지, 음악, 텍스트)
- 인코딩 처리 X
문자 스트림 (Reader, Writer):
- 1문자 단위 (Java 의 char, 2바이트)
- 텍스트 전용
- 인코딩 처리 자동
변환:
InputStreamReader: InputStream → Reader
OutputStreamWriter: OutputStream → Writer
예:
Reader r = new InputStreamReader(System.in, "UTF-8");1.4 Decorator 패턴
// java.io 의 핵심 디자인 패턴
// "기본 스트림 + 보조 스트림" 조합
// 기본: FileInputStream (파일에서 1바이트씩)
FileInputStream fis = new FileInputStream("file.txt");
// 보조 1: 버퍼 추가
BufferedInputStream bis = new BufferedInputStream(fis);
// 보조 2: 데이터 타입 처리
DataInputStream dis = new DataInputStream(bis);
// 또는 한 줄로 (중첩)
DataInputStream dis = new DataInputStream(
new BufferedInputStream(
new FileInputStream("file.txt")));
// 읽기
int value = dis.readInt();특징:
- 기본 스트림에 보조 스트림 입혀서 기능 추가
- 유연하지만 중첩이 깊음
1.5 IO 의 기본 사용
// 파일 읽기
try (FileInputStream fis = new FileInputStream("input.txt")) {
int b;
while ((b = fis.read()) != -1) {
System.out.print((char) b);
}
}
// 파일 쓰기
try (FileOutputStream fos = new FileOutputStream("output.txt")) {
fos.write("Hello".getBytes());
}
// 텍스트 읽기 (한 줄씩)
try (BufferedReader br = new BufferedReader(new FileReader("input.txt"))) {
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
}
// 텍스트 쓰기
try (BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {
bw.write("Hello\n");
bw.write("World\n");
}1.6 IO 의 직렬화 지원
// 객체 직렬화 (Java 1.1+)
class Shipment implements Serializable {
private Long id;
private String blNo;
// ...
}
// 저장
try (ObjectOutputStream oos = new ObjectOutputStream(
new FileOutputStream("shipment.dat"))) {
oos.writeObject(shipment);
}
// 복원
try (ObjectInputStream ois = new ObjectInputStream(
new FileInputStream("shipment.dat"))) {
Shipment loaded = (Shipment) ois.readObject();
}→ Unit 9.4 에서 정밀.
1.7 IO 의 단점 미리보기
IO 의 한계 (다음 섹션에서 정밀):
1. 1바이트씩 → 느림
2. 단방향 → InputStream/OutputStream 따로
3. Blocking only → 동시성 ↓
4. 중첩 패턴 → 가독성 ↓
5. File 의 한계 → Unit 7.5 에서 정밀1.8 ILIC 의 IO 활용
// ILIC 의 직렬화
public class ShipmentSerializer {
public void serialize(Shipment shipment, Path dest) throws IOException {
try (ObjectOutputStream oos = new ObjectOutputStream(
new BufferedOutputStream(
new FileOutputStream(dest.toFile())))) {
oos.writeObject(shipment);
}
}
public Shipment deserialize(Path src) throws IOException, ClassNotFoundException {
try (ObjectInputStream ois = new ObjectInputStream(
new BufferedInputStream(
new FileInputStream(src.toFile())))) {
return (Shipment) ois.readObject();
}
}
}
// Decorator 패턴 — 중첩
// 1. FileInputStream — 기본 파일
// 2. BufferedInputStream — 버퍼링
// 3. ObjectInputStream — 객체 복원1.9 자기 점검 답변
IO (java.io) 의 핵심 구조는?
답:
1. 스트림 기반:
- 1바이트 (또는 1문자) 단위
- InputStream/OutputStream (바이트)
- Reader/Writer (문자)
-
단방향:
- Input 과 Output 따로
- 양방향이 필요하면 두 스트림
-
Blocking only:
- 데이터 올 때까지 대기
- 다른 일 못 함
-
Decorator 패턴:
- 기본 스트림 + 보조 스트림
- 중첩으로 기능 추가
-
두 가지 스트림:
- 바이트 (모든 데이터)
- 문자 (텍스트, 인코딩)
2️⃣ IO 의 5가지 한계
2.1 한계 1 — 1바이트씩 처리의 느림
// IO 의 기본 read() — 1바이트
FileInputStream fis = new FileInputStream("large.dat");
int b;
while ((b = fis.read()) != -1) {
// 1바이트 처리
}
// 1MB 파일 = 1,048,576번 호출
// 각 호출이 OS 의 system call
// → 매우 느림// 해결: BufferedInputStream
BufferedInputStream bis = new BufferedInputStream(fis);
int b;
while ((b = bis.read()) != -1) {
// 여전히 1바이트씩 호출하지만
// 내부적으로 8KB 단위로 OS 호출
// → 1MB / 8KB = 128번 호출
}
// 또는 byte[] 활용
byte[] buf = new byte[8192];
int n;
while ((n = fis.read(buf)) != -1) {
// 한 번에 8192바이트
}→ 보조 스트림 (BufferedInputStream) 으로 일부 해결.
2.2 한계 2 — 단방향성
// 같은 파일을 읽고 쓰기 위해 두 스트림 필요
FileInputStream fis = new FileInputStream("file.txt");
FileOutputStream fos = new FileOutputStream("file.txt");
// 또는 동시 가능한 RandomAccessFile (드물게 사용)
RandomAccessFile raf = new RandomAccessFile("file.txt", "rw");
raf.seek(0);
int b = raf.read();
raf.write(b + 1);// NIO 의 해결: Channel (양방향)
try (FileChannel channel = FileChannel.open(
Path.of("file.txt"),
StandardOpenOption.READ, StandardOpenOption.WRITE)) {
ByteBuffer buffer = ByteBuffer.allocate(1024);
channel.read(buffer); // 같은 channel 로 읽기
buffer.flip();
channel.write(buffer); // 같은 channel 로 쓰기
}2.3 한계 3 — Blocking 의 동시성 문제
// IO 는 항상 Blocking
ServerSocket server = new ServerSocket(8080);
Socket client = server.accept(); // ★ 연결 올 때까지 정지
InputStream in = client.getInputStream();
int b = in.read(); // ★ 데이터 올 때까지 정지
// 동시 처리하려면?
// 옵션: 스레드 per 연결
ExecutorService pool = Executors.newCachedThreadPool();
while (true) {
Socket s = server.accept();
pool.submit(() -> handleClient(s));
}
// 1만 연결 = 1만 스레드 = 큰 메모리 부담// NIO 의 해결: Non-blocking + Selector
ServerSocketChannel server = ServerSocketChannel.open();
server.configureBlocking(false);
server.bind(new InetSocketAddress(8080));
Selector selector = Selector.open();
server.register(selector, SelectionKey.OP_ACCEPT);
while (true) {
selector.select(); // 한 스레드가 여러 채널 모니터
// ... 한 스레드로 1만 연결 처리
}2.4 한계 4 — Decorator 패턴의 복잡함
// 일반적 IO 사용 — 중첩 깊음
ObjectInputStream ois = new ObjectInputStream(
new BufferedInputStream(
new GZIPInputStream(
new FileInputStream("data.dat.gz"))));
// 4중 중첩!
// 1. FileInputStream — 파일
// 2. GZIPInputStream — 압축 해제
// 3. BufferedInputStream — 버퍼링
// 4. ObjectInputStream — 객체 복원
// 가독성 ↓
// close 도 복잡 (가장 바깥만 close 하면 안쪽도 close 되지만)// NIO.2 의 해결: 더 간결
String content = Files.readString(Path.of("file.txt")); // 한 줄
List<String> lines = Files.readAllLines(Path.of("file.txt"));
try (Stream<String> lines = Files.lines(Path.of("file.txt"))) {
lines.forEach(System.out::println);
}2.5 한계 5 — File 클래스의 한계
// File 클래스의 한계
File file = new File("/path/to/file");
// 1. boolean 반환 — 진단 어려움
boolean created = file.createNewFile(); // 왜 실패?
boolean deleted = file.delete(); // 왜 실패?
// 2. 심볼릭 링크 처리 X
file.exists(); // 링크? 원본?
// 3. 풍부한 속성 X
file.canRead();
file.length();
file.lastModified();
// 끝 (POSIX 권한 등 없음)
// 4. 비효율적 디렉토리 순회
File[] children = dir.listFiles(); // 모두 메모리에
// 5. 파일 시스템 추상화 X
// ZIP, 메모리, 네트워크 파일 시스템 불가// NIO.2 의 해결: Files + Path
Path path = Path.of("/path/to/file");
// 1. 명확한 예외
try {
Files.createFile(path);
} catch (FileAlreadyExistsException e) { ... }
catch (AccessDeniedException e) { ... }
// 2. 심볼릭 링크 옵션
Files.exists(path, LinkOption.NOFOLLOW_LINKS);
// 3. 풍부한 속성
PosixFileAttributes attrs = Files.readAttributes(path, PosixFileAttributes.class);
Set<PosixFilePermission> perms = attrs.permissions();
// 4. Stream 기반 순회
try (Stream<Path> paths = Files.list(dir)) { ... }
// 5. 파일 시스템 추상화
FileSystem zipFs = FileSystems.newFileSystem(zipPath);2.6 IO 의 5가지 한계 종합
IO (Java 1.0) 의 5가지 한계:
1. 1바이트씩 처리
→ 느림 (system call 빈번)
→ Buffered 로 일부 해결
2. 단방향
→ 양방향 작업 시 두 스트림 필요
→ NIO 의 Channel 이 해결
3. Blocking only
→ 동시성 ↓
→ 1만 연결 = 1만 스레드
→ NIO 의 Non-blocking 이 해결
4. Decorator 패턴 복잡
→ 중첩 깊음
→ NIO.2 의 Files 가 간결
5. File 의 한계
→ 진단 부실, 속성 부족
→ NIO.2 의 Path/Files 가 해결2.7 자기 점검 답변
IO 의 5가지 한계와 해결책은?
답:
1. 1바이트씩 → 느림: Buffered + byte[] 일부 해결
2. 단방향 → 양방향 작업 어려움: NIO Channel 해결
3. Blocking → 동시성 ↓: NIO Non-blocking 해결
4. Decorator 중첩 복잡: NIO.2 Files 간결
5. File 클래스 한계: NIO.2 Path/Files 해결
→ NIO + NIO.2 가 모두 해결.
3️⃣ NIO 의 등장과 핵심 개념 (Java 1.4)
3.1 NIO 의 등장
NIO (New I/O):
- Java 1.4 (2002)
- java.nio 패키지
- IO 의 한계 해결 목표
핵심 변화:
1. 스트림 → 채널 + 버퍼
2. 단방향 → 양방향
3. Blocking → Non-blocking 가능
4. 1바이트 → 블록 단위
원동력:
- 1990 년대 후반 인터넷 폭발
- 대규모 서버 필요
- 동시 연결 처리 요구3.2 NIO 의 3가지 핵심
NIO 의 핵심 개념:
1. Channel (채널):
- 양방향 데이터 통로
- 파일, 소켓 등을 추상화
- read/write 메서드
2. Buffer (버퍼):
- 데이터의 컨테이너
- 채널과 데이터 교환의 중간 매개
- 위치 (position), 한계 (limit), 용량 (capacity)
3. Selector (셀렉터):
- 여러 채널 모니터
- 준비된 채널만 처리
- 한 스레드로 다수 처리3.3 Channel 의 정의
package java.nio.channels;
public interface Channel extends Closeable {
boolean isOpen();
void close() throws IOException;
}
// 양방향 채널
public interface ReadableByteChannel extends Channel {
int read(ByteBuffer dst) throws IOException;
}
public interface WritableByteChannel extends Channel {
int write(ByteBuffer src) throws IOException;
}
public interface ByteChannel extends ReadableByteChannel, WritableByteChannel {
// 양방향
}자바 표준 Channel 구현:
- FileChannel: 파일
- SocketChannel: TCP 클라이언트
- ServerSocketChannel: TCP 서버
- DatagramChannel: UDP
- Pipe.SinkChannel/SourceChannel: 파이프
3.4 Buffer 의 구조
Buffer 의 4가지 속성:
capacity: 버퍼의 최대 크기 (불변)
position: 다음 읽기/쓰기 위치
limit: 읽기/쓰기 가능한 마지막 위치
mark: position 의 임시 저장 (북마크)
조건:
0 ≤ mark ≤ position ≤ limit ≤ capacity
상태:
[0 .................. capacity]
↑position ↑limit
쓰기 모드: position 이 다음 쓸 위치, limit = capacity
읽기 모드: position 이 다음 읽을 위치, limit = 쓴 데이터의 끝3.5 Buffer 의 메서드
// 생성
ByteBuffer buffer = ByteBuffer.allocate(1024); // heap
ByteBuffer direct = ByteBuffer.allocateDirect(1024); // 직접 메모리
// 쓰기 (put)
buffer.put((byte) 65);
buffer.putInt(42);
buffer.putLong(123L);
// 읽기/쓰기 모드 전환
buffer.flip(); // 쓰기 → 읽기
// 읽기 (get)
byte b = buffer.get();
int n = buffer.getInt();
long l = buffer.getLong();
// 초기화
buffer.clear(); // 처음으로
buffer.rewind(); // position 만 0
buffer.compact(); // 안 읽은 데이터를 앞으로
// 정보
buffer.remaining(); // limit - position
buffer.hasRemaining();3.6 Channel + Buffer 의 사용
// 파일 읽기 — NIO
try (FileChannel channel = FileChannel.open(Path.of("file.txt"))) {
ByteBuffer buffer = ByteBuffer.allocate(1024);
int bytesRead = channel.read(buffer);
while (bytesRead > 0) {
buffer.flip(); // 쓰기 → 읽기 모드
while (buffer.hasRemaining()) {
System.out.print((char) buffer.get());
}
buffer.clear(); // 다시 쓰기 모드
bytesRead = channel.read(buffer);
}
}3.7 Selector — 멀티플렉서
// 한 스레드가 여러 채널 모니터
Selector selector = Selector.open();
// 서버 채널 등록
ServerSocketChannel server = ServerSocketChannel.open();
server.configureBlocking(false);
server.bind(new InetSocketAddress(8080));
server.register(selector, SelectionKey.OP_ACCEPT);
while (true) {
selector.select(); // ★ 준비된 채널 대기 (Blocking, 하지만 한 번만)
Set<SelectionKey> keys = selector.selectedKeys();
Iterator<SelectionKey> it = keys.iterator();
while (it.hasNext()) {
SelectionKey key = it.next();
it.remove();
if (key.isAcceptable()) {
// 새 연결
SocketChannel client = server.accept();
client.configureBlocking(false);
client.register(selector, SelectionKey.OP_READ);
} else if (key.isReadable()) {
// 데이터 도착
SocketChannel client = (SocketChannel) key.channel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
client.read(buffer);
// 처리
}
}
}
// 한 스레드로 수천 연결 처리 가능3.8 NIO 가 해결한 IO 의 한계
NIO 의 개선:
1. 블록 단위 (Buffer)
→ 1바이트 처리의 느림 해결
2. 양방향 (Channel)
→ 단방향의 불편함 해결
3. Non-blocking (configureBlocking(false))
→ Blocking 의 동시성 문제 해결
4. Selector
→ 한 스레드로 다수 처리
5. Direct Buffer
→ 직접 메모리 사용
→ JVM heap 우회
→ 네트워크 I/O 빠름3.9 ILIC 활용 예
// NIO 로 파일 복사 — 고속
public class FastFileCopier {
public void copy(Path src, Path dest) throws IOException {
try (FileChannel srcChannel = FileChannel.open(src, StandardOpenOption.READ);
FileChannel destChannel = FileChannel.open(dest,
StandardOpenOption.CREATE, StandardOpenOption.WRITE)) {
// 채널 간 직접 전송 — 매우 빠름
srcChannel.transferTo(0, srcChannel.size(), destChannel);
// 또는: destChannel.transferFrom(srcChannel, 0, srcChannel.size());
}
}
}
// NIO 의 transferTo:
// - OS 의 zero-copy 활용 가능
// - 커널 ↔ 유저 공간 복사 회피
// - 일반 I/O 보다 수십% 빠름3.10 자기 점검 답변
NIO 의 3가지 핵심 개념은?
답:
1. Channel (채널):
- 양방향 데이터 통로
- FileChannel, SocketChannel 등
- read/write 메서드
-
Buffer (버퍼):
- 데이터의 컨테이너
- position, limit, capacity, mark
- 쓰기/읽기 모드 전환 (flip)
-
Selector (셀렉터):
- 여러 채널 모니터
- 한 스레드로 다수 처리
- Non-blocking 의 핵심
→ Unit 7.3, 7.4 에서 정밀.
4️⃣ NIO.2 의 등장과 추가 기능 (Java 7)
4.1 NIO.2 의 등장
NIO.2:
- Java 7 (2011)
- java.nio.file 패키지
- NIO 의 후속 (NIO 와는 다른 영역)
NIO 가 해결한 것:
- 채널, 버퍼, Non-blocking (네트워크 위주)
NIO 가 못 해결한 것:
- 파일 시스템 API (여전히 File 클래스)
- 비동기 I/O (콜백 X)
NIO.2 가 해결:
- Path, Files (현대 파일 API)
- WatchService (변경 감지)
- 비동기 채널
- 파일 시스템 추상화4.2 NIO.2 의 핵심 추가
NIO.2 의 추가 기능:
1. Path 인터페이스
- 경로 객체 (불변)
- File 대체
2. Files 정적 유틸리티
- 모든 파일 작업
- Stream 통합
3. WatchService
- 파일 변경 감지
4. 비동기 채널
- AsynchronousFileChannel
- AsynchronousSocketChannel
5. 파일 시스템 추상화
- FileSystem, FileSystems
- ZIP, 메모리 FS 등4.3 Path 와 Files
// 기본 사용
Path path = Path.of("/home/user/file.txt");
// 또는 Paths.get(...)
// Files 의 풍부한 메서드
Files.exists(path);
Files.isDirectory(path);
Files.isRegularFile(path);
Files.isReadable(path);
Files.readString(path);
Files.writeString(path, "content");
Files.readAllLines(path);
Files.write(path, lines);
Files.copy(src, dest);
Files.move(src, dest);
Files.delete(path);
Files.createFile(path);
Files.createDirectory(path);
Files.createDirectories(path); // 중간 디렉토리도
// Stream 통합
try (Stream<String> lines = Files.lines(path)) {
lines.forEach(System.out::println);
}
try (Stream<Path> paths = Files.list(dir)) { ... }
try (Stream<Path> paths = Files.walk(dir)) { ... }4.4 WatchService — 파일 감시
// 파일/디렉토리 변경 감지
try (WatchService watcher = FileSystems.getDefault().newWatchService()) {
Path dir = Path.of("/path/to/watch");
dir.register(watcher,
StandardWatchEventKinds.ENTRY_CREATE,
StandardWatchEventKinds.ENTRY_DELETE,
StandardWatchEventKinds.ENTRY_MODIFY);
while (true) {
WatchKey key = watcher.take(); // 이벤트 대기
for (WatchEvent<?> event : key.pollEvents()) {
WatchEvent.Kind<?> kind = event.kind();
Path changedFile = (Path) event.context();
System.out.println(kind + ": " + changedFile);
}
if (!key.reset()) break;
}
}
// 활용:
// - 설정 파일 hot reload
// - 로그 파일 분석
// - 파일 동기화4.5 비동기 채널
// AsynchronousFileChannel — 비동기 파일
AsynchronousFileChannel channel = AsynchronousFileChannel.open(
Path.of("file.txt"), StandardOpenOption.READ);
ByteBuffer buffer = ByteBuffer.allocate(1024);
// 방법 1: Future
Future<Integer> future = channel.read(buffer, 0);
// 다른 일 가능
int bytesRead = future.get(); // 완료 대기
// 방법 2: CompletionHandler (콜백)
channel.read(buffer, 0, null, new CompletionHandler<Integer, Object>() {
@Override
public void completed(Integer result, Object attachment) {
System.out.println("Read " + result + " bytes");
}
@Override
public void failed(Throwable exc, Object attachment) {
exc.printStackTrace();
}
});4.6 파일 시스템 추상화
// 기본 파일 시스템
FileSystem defaultFs = FileSystems.getDefault();
// ZIP 파일을 파일 시스템처럼
try (FileSystem zipFs = FileSystems.newFileSystem(Path.of("archive.zip"), null)) {
Path inZip = zipFs.getPath("/inner-file.txt");
String content = Files.readString(inZip);
// ZIP 안의 파일을 일반 파일처럼 다룸
}
// 메모리 파일 시스템 (Google jimfs 같은 라이브러리)
// 네트워크 파일 시스템
// 사용자 정의 파일 시스템
// 동일한 API 로 모두 처리 — 추상화의 힘4.7 NIO.2 의 효과
NIO.2 가 만든 변화:
1. 간결성
- String content = Files.readString(path);
- 한 줄로 끝
2. Stream 통합
- Files.lines, list, walk
- 함수형 프로그래밍 자연스러움
3. 명확한 예외
- 구체적 예외 계층
- 디버깅 용이
4. 풍부한 속성
- 시간, 권한, 소유자
- POSIX 지원
5. 추상화
- ZIP, 메모리 FS 등
- 동일 API4.8 ILIC 활용
public class ShipmentFileService {
private final Path baseDir = Path.of("/var/shipment");
// NIO.2 의 간결한 파일 작업
public List<Shipment> importFromCsv(Path src) throws IOException {
try (Stream<String> lines = Files.lines(src)) {
return lines
.skip(1) // 헤더 건너뛰기
.map(this::parseShipment)
.toList();
}
}
public void exportToCsv(List<Shipment> shipments, Path dest) throws IOException {
List<String> lines = new ArrayList<>();
lines.add("id,blNo,weight,createdAt");
shipments.forEach(s -> lines.add(s.toCsvLine()));
Files.write(dest, lines);
}
public void copyToArchive(Path src) throws IOException {
Path archive = baseDir.resolve("archive").resolve(src.getFileName());
Files.createDirectories(archive.getParent());
Files.copy(src, archive, StandardCopyOption.REPLACE_EXISTING);
}
public Stream<Path> findOldFiles(int days) throws IOException {
Instant threshold = Instant.now().minus(days, ChronoUnit.DAYS);
return Files.walk(baseDir)
.filter(Files::isRegularFile)
.filter(p -> {
try {
return Files.getLastModifiedTime(p).toInstant().isBefore(threshold);
} catch (IOException e) {
return false;
}
});
}
}4.9 자기 점검 답변
NIO.2 가 NIO 와 다른 점은?
답:
-
NIO (Java 1.4):
- 채널 + 버퍼
- Non-blocking 가능
- 네트워크 I/O 강화
- 파일 API 여전히 File 클래스
-
NIO.2 (Java 7):
- Path, Files (현대 파일 API)
- Stream 통합
- WatchService (변경 감지)
- 비동기 채널
- 파일 시스템 추상화
핵심: NIO.2 는 NIO 의 후속이지만 주로 파일 시스템 API 의 현대화. 자세히는 Unit 7.5 에서.
5️⃣ 3 시대 종합 비교
5.1 종합 비교 표
| 항목 | IO (Java 1.0, 1996) | NIO (Java 1.4, 2002) | NIO.2 (Java 7, 2011) |
|---|---|---|---|
| 패키지 | java.io | java.nio, java.nio.channels | java.nio.file |
| 단위 | 스트림 (1바이트/문자) | 채널 + 버퍼 (블록) | 채널 + 버퍼 + Path |
| 방향 | 단방향 | 양방향 | 양방향 |
| Blocking | 항상 | Non-blocking 가능 | Non-blocking + Async |
| 파일 API | File | FileChannel | Path + Files (static) |
| Stream 통합 | X | X | ✓ (Files.lines, walk) |
| 멀티플렉싱 | X | Selector | Selector + Async |
| 비동기 | X | X | AsynchronousChannel |
| 파일 시스템 추상화 | X | X | ✓ (FileSystem) |
| 변경 감지 | X | X | ✓ (WatchService) |
| 디렉토리 순회 | listFiles (메모리) | (X) | Stream 기반 (lazy) |
| 가독성 | 중첩 많음 | 복잡 (Buffer 다룸) | 간결 |
5.2 시각적 비교
파일 읽기 — 같은 작업을 3가지 방식으로
IO (java.io):
try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
String line;
while ((line = br.readLine()) != null) {
// 처리
}
}
특징:
- Decorator 중첩
- 한 줄씩 처리
- Blocking
NIO (java.nio):
try (FileChannel channel = FileChannel.open(Path.of("file.txt"))) {
ByteBuffer buffer = ByteBuffer.allocate(1024);
while (channel.read(buffer) > 0) {
buffer.flip();
// 처리
buffer.clear();
}
}
특징:
- Buffer 관리
- 블록 단위
- 코드 복잡
NIO.2 (java.nio.file):
try (Stream<String> lines = Files.lines(Path.of("file.txt"))) {
lines.forEach(line -> /* 처리 */);
}
특징:
- 한 줄
- Stream 통합
- 가독성 ↑5.3 IO/NIO/NIO.2 공존
세 시대가 모두 살아있다.
이유:
- 하위 호환성
- 각각 적합한 시나리오
- 라이브러리 의존성
예:
- 직렬화: 여전히 java.io (ObjectInputStream)
- 네트워크 (단순): java.io 가능
- 네트워크 (대규모): java.nio 필수
- 파일: NIO.2 권장
- Spring Boot: NIO 기반 (Netty/Tomcat)5.4 진화의 패턴
자바 I/O 진화의 일관된 패턴:
1. 한계 발견
IO: 1바이트씩, Blocking
↓
2. 새 추상화 도입
NIO: Channel + Buffer + Selector
↓
3. 부족한 부분 보강
NIO.2: Path + Files + Async
↓
4. 하위 호환 유지
- 옛 코드 계속 동작
- 새 코드는 새 API5.5 자바 I/O 의 역사 (정리)
1996: Java 1.0
- java.io 등장
- InputStream, OutputStream
- Decorator 패턴
1997: Java 1.1
- Reader, Writer 추가
- 문자 스트림
- 직렬화 (Serializable)
2002: Java 1.4
- java.nio (NIO)
- Channel, Buffer, Selector
- Non-blocking 가능
2011: Java 7
- java.nio.file (NIO.2)
- Path, Files, WatchService
- 비동기 채널
- try-with-resources
2014: Java 8
- Stream API 등장
- Files.lines 의 강력함
2017: Java 9
- try-with-resources effectively final
- HttpClient (preview)
2018: Java 11
- HttpClient 표준화
- 단순한 네트워크 API
2021+: Java 17+
- 점진적 개선
- Project Loom (가상 스레드)
- 비동기 패러다임 변화5.6 자기 점검 답변
IO/NIO/NIO.2 의 4가지 핵심 차이는?
답:
1. 단위:
- IO: 스트림 (1바이트/문자)
- NIO: 채널 + 버퍼 (블록)
- NIO.2: 채널 + 버퍼 + Path
-
방향:
- IO: 단방향
- NIO/NIO.2: 양방향
-
Blocking:
- IO: 항상
- NIO: Non-blocking 가능
- NIO.2: Non-blocking + Async
-
파일 API:
- IO: File
- NIO: FileChannel
- NIO.2: Path + Files (static)
6️⃣ File 클래스 vs Files 유틸리티
6.1 File 클래스 (Java 1.0)
// File 의 기본 사용
File file = new File("/path/to/file.txt");
// 1. 객체 생성 필요
// 2. 인스턴스 메서드들
file.exists();
file.length();
file.canRead();
file.canWrite();
file.lastModified();
file.getName();
file.getParent();
file.getPath();
file.getAbsolutePath();
file.getCanonicalPath(); // throws IOException
file.createNewFile(); // boolean 반환
file.delete(); // boolean 반환
file.renameTo(dest); // boolean 반환
file.mkdirs(); // boolean 반환
file.listFiles(); // 디렉토리의 모든 파일 배열
file.list(); // 이름 배열특징:
- 객체 생성 후 사용
- boolean 반환 (실패 원인 모름)
- 제한된 기능
6.2 Files 유틸리티 (Java 7+)
// Files 의 사용
Path path = Path.of("/path/to/file.txt");
// 1. 객체 생성 불필요 (Path 만 있으면)
// 2. static 메서드들
// 조회
Files.exists(path);
Files.size(path);
Files.isReadable(path);
Files.isWritable(path);
Files.isExecutable(path);
Files.isDirectory(path);
Files.isRegularFile(path);
Files.isSymbolicLink(path);
Files.isHidden(path);
Files.getLastModifiedTime(path);
Files.getOwner(path);
Files.getAttribute(path, "...");
// 생성/삭제 — 예외로 명확
Files.createFile(path); // throws IOException
Files.delete(path); // throws IOException
Files.move(src, dest); // throws IOException
Files.copy(src, dest); // throws IOException
Files.createDirectory(path);
Files.createDirectories(path);
// 읽기/쓰기 — 한 줄!
String content = Files.readString(path);
List<String> lines = Files.readAllLines(path);
byte[] bytes = Files.readAllBytes(path);
Files.writeString(path, "content");
Files.write(path, lines);
Files.write(path, bytes);
// Stream
try (Stream<String> lines = Files.lines(path)) { ... }
try (Stream<Path> paths = Files.list(dir)) { ... }
try (Stream<Path> paths = Files.walk(dir)) { ... }6.3 결정적 차이
File 의 한계:
- "객체 생성 후 사용"
- 객체가 무거움 (실제 파일 정보 일부 캐시)
- 메서드가 boolean 반환 → 진단 어려움
- 풍부한 속성 X
- 심볼릭 링크 처리 X
Files 의 장점:
- "static 호출"
- Path 만 있으면 됨 (가벼움)
- 명확한 예외
- 풍부한 속성 (BasicFileAttributes, PosixFileAttributes)
- 심볼릭 링크 옵션 (LinkOption.NOFOLLOW_LINKS)6.4 비교 표
| 항목 | File | Files |
|---|---|---|
| Java 버전 | 1.0+ | 7+ |
| 패키지 | java.io | java.nio.file |
| 사용 방식 | 인스턴스화 | static 호출 |
| 에러 처리 | boolean | 명확한 예외 |
| 심볼릭 링크 | X | LinkOption |
| Stream | X | Files.lines/list/walk |
| 속성 | 기본만 | 풍부 (POSIX 등) |
| 비동기 | X | AsynchronousChannel 가능 |
| 파일 시스템 | 로컬만 | FileSystem 추상화 |
6.5 File 의 활용 패턴 (레거시)
// 전통 File 사용
File dir = new File("/var/data");
// 디렉토리 생성
if (!dir.exists()) {
if (!dir.mkdirs()) {
throw new RuntimeException("Cannot create dir");
// 왜 실패했는지 모름!
}
}
// 파일 순회
File[] files = dir.listFiles((d, name) -> name.endsWith(".txt"));
// 모든 파일을 한 번에 메모리에 로드
// 디렉토리가 크면 OOM 위험
for (File file : files) {
System.out.println(file.getName());
if (file.length() > 1_000_000) {
// 1MB 이상
}
}6.6 Files 의 활용 패턴 (현대)
// 현대 Files 사용
Path dir = Path.of("/var/data");
// 디렉토리 생성
Files.createDirectories(dir);
// 이미 존재하면 무시
// 실패 시 명확한 예외 (AccessDenied, IOException 등)
// 파일 순회 — Stream
try (Stream<Path> files = Files.list(dir)) {
files.filter(p -> p.toString().endsWith(".txt"))
.filter(p -> {
try {
return Files.size(p) > 1_000_000;
} catch (IOException e) {
return false;
}
})
.forEach(p -> System.out.println(p.getFileName()));
}
// Lazy + 메모리 효율적6.7 File ↔ Path 변환
// File → Path (자바 7+)
File file = new File("file.txt");
Path path = file.toPath();
// Path → File
Path path = Path.of("file.txt");
File file = path.toFile();
// 활용
// 레거시 라이브러리가 File 받음
public void legacyMethod(File f) { ... }
// 새 코드는 Path 권장
Path myPath = Path.of("/data");
legacyMethod(myPath.toFile());6.8 ILIC 의 File → Files 마이그레이션
// 옛 코드 (File 기반)
public class OldExporter {
public void export(String dirPath, String fileName) throws IOException {
File dir = new File(dirPath);
if (!dir.exists() && !dir.mkdirs()) {
throw new IOException("Cannot create dir");
}
File file = new File(dir, fileName);
if (!file.createNewFile() && !file.exists()) {
throw new IOException("Cannot create file");
}
try (FileWriter writer = new FileWriter(file)) {
writer.write("data");
}
}
}
// 새 코드 (Files 기반)
public class NewExporter {
public void export(String dirPath, String fileName) throws IOException {
Path dir = Path.of(dirPath);
Files.createDirectories(dir); // 명확한 예외
Path file = dir.resolve(fileName);
Files.writeString(file, "data");
// 한 줄로 끝
}
}6.9 자기 점검 답변
File 과 Files 의 결정적 차이는?
답:
1. 사용 방식:
- File: 인스턴스화 (
new File(...)) - Files: static 호출 (
Files.exists(path))
-
에러 처리:
- File: boolean (왜 실패? 모름)
- Files: 명확한 예외 (FileAlreadyExistsException 등)
-
기능:
- File: 기본만 (length, lastModified)
- Files: 풍부 (POSIX 권한, 심볼릭 링크, Stream 등)
-
Stream 통합:
- File: X
- Files: Files.lines/list/walk
-
권장:
- 새 코드: Files
- 레거시 호환: File ↔ Path 변환
7️⃣ 단방향 vs 양방향, Blocking vs Non-blocking
7.1 단방향 (IO)
// java.io 의 스트림 — 단방향
// 읽기 전용
InputStream in = new FileInputStream("file.txt");
in.read(); // 가능
// in.write(...); // 메서드 없음
// 쓰기 전용
OutputStream out = new FileOutputStream("file.txt");
out.write(65);
// out.read(); // 메서드 없음
// 양방향 작업 시 두 스트림 필요
InputStream in = new FileInputStream("file.txt");
OutputStream out = new FileOutputStream("file.txt");
// 두 개를 관리해야7.2 양방향 (NIO)
// NIO 의 Channel — 양방향
try (FileChannel channel = FileChannel.open(
Path.of("file.txt"),
StandardOpenOption.READ, StandardOpenOption.WRITE)) {
// 같은 채널로 읽기
ByteBuffer readBuf = ByteBuffer.allocate(1024);
channel.read(readBuf);
// 같은 채널로 쓰기
ByteBuffer writeBuf = ByteBuffer.wrap("Hello".getBytes());
channel.write(writeBuf);
}
// SocketChannel — 네트워크 양방향
SocketChannel socket = SocketChannel.open(new InetSocketAddress(host, port));
socket.read(buffer); // 서버로부터 읽기
socket.write(buffer); // 서버로 쓰기7.3 단방향 vs 양방향 의 효과
단방향의 효과:
+ 단순한 API
+ 명확한 의도 (in 인지 out 인지)
- 양방향 작업 시 객체 관리 ↑
- 메모리 사용 ↑
양방향의 효과:
+ 효율적 (한 객체로 모두)
+ Random Access 자연스러움
+ 같은 채널로 read + write
- API 복잡
- 모드 관리 필요7.4 Blocking 의 동작
// Blocking IO
ServerSocket server = new ServerSocket(8080);
Socket client = server.accept(); // ★ 클라이언트 연결 올 때까지 대기
InputStream in = client.getInputStream();
int b = in.read(); // ★ 데이터 올 때까지 대기
out.write(response.getBytes()); // ★ 모든 데이터 보낼 때까지 대기
// 한 스레드가 한 연결만 처리 가능
// 여러 연결 = 여러 스레드7.5 Non-blocking 의 동작
// Non-blocking NIO
ServerSocketChannel server = ServerSocketChannel.open();
server.configureBlocking(false); // ★ Non-blocking 모드
server.bind(new InetSocketAddress(8080));
while (true) {
SocketChannel client = server.accept(); // ★ 즉시 리턴 (없으면 null)
if (client == null) {
// 다른 일 가능
continue;
}
client.configureBlocking(false);
ByteBuffer buffer = ByteBuffer.allocate(1024);
int n = client.read(buffer); // ★ 즉시 리턴
if (n == 0) {
// 데이터 없음, 다른 일 가능
} else if (n > 0) {
// 데이터 있음, 처리
}
}
// 또는 Selector 활용
// 한 스레드로 다수 연결 처리7.6 Blocking vs Non-blocking 의 효과
Blocking:
+ 단순한 코드
+ 디버깅 쉬움
- 동시성 ↓ (스레드 per 연결)
- 메모리 ↑
Non-blocking:
+ 동시성 ↑ (한 스레드로 다수)
+ 메모리 효율
- 코드 복잡
- Selector 등 추가 추상화 필요
- 디버깅 어려움7.7 비교 시각화
시나리오: 1만 동시 연결 처리
Blocking:
스레드 1만 개 필요
- 각 스레드: 1MB 스택
- 메모리: 10GB
- 컨텍스트 스위칭 비용 ↑
- CPU 캐시 효율 ↓
Non-blocking:
스레드 8~16 개 (CPU 코어 수)
- 한 스레드가 수천 연결 모니터
- 메모리: 수십 MB
- 효율적7.8 ILIC 의 활용
// ILIC 의 Spring Boot
// 기본 Tomcat: NIO 기반 (Non-blocking)
// 또는 WebFlux: Reactor + Netty (완전 비동기)
@RestController
public class ApiController {
@GetMapping("/api/shipments/{id}")
public ShipmentResponse get(@PathVariable Long id) {
// 동기 API 처럼 보이지만
// 서블릿 컨테이너는 NIO 활용
return service.findById(id);
}
}
// WebFlux (완전 비동기)
@RestController
public class ReactiveController {
@GetMapping("/api/shipments/{id}")
public Mono<ShipmentResponse> get(@PathVariable Long id) {
return service.findByIdAsync(id);
// Non-blocking, Reactive
}
}7.9 자기 점검 답변
단방향/양방향, Blocking/Non-blocking 의 의미는?
답:
-
단방향 vs 양방향:
- IO: 단방향 (InputStream OR OutputStream)
- NIO: 양방향 (Channel)
- 효과: 객체 관리, 메모리 효율
-
Blocking vs Non-blocking:
- Blocking: 호출이 결과까지 정지
- Non-blocking: 즉시 리턴
- 동시성에 결정적
→ Unit 7.4 (마스터 깊이) 에서 정밀.
8️⃣ 실무 활용 가이드
8.1 언제 어느 것을 쓰나?
실무 선택 가이드:
NIO.2 (java.nio.file) 권장:
✓ 파일 작업 일반
✓ Stream 활용
✓ 새 코드
NIO (java.nio) 권장:
✓ 대규모 네트워크
✓ 직접 메모리 (DirectBuffer)
✓ zero-copy (transferTo)
✓ Custom 프로토콜 구현
IO (java.io) 권장:
✓ 직렬화 (ObjectStream)
✓ Reader/Writer (텍스트)
✓ 단순한 콘솔 I/O
✓ 레거시 호환8.2 시나리오별 선택
시나리오 1: 파일 한 줄씩 처리
IO 방식 (옛):
BufferedReader br = new BufferedReader(new FileReader("file.txt"));
String line;
while ((line = br.readLine()) != null) {
// 처리
}
br.close();
NIO.2 방식 (권장):
try (Stream<String> lines = Files.lines(Path.of("file.txt"))) {
lines.forEach(line -> /* 처리 */);
}
// 더 간결, Stream API 활용시나리오 2: 대용량 파일 복사
IO 방식 (옛):
try (InputStream in = new BufferedInputStream(new FileInputStream(src));
OutputStream out = new BufferedOutputStream(new FileOutputStream(dest))) {
byte[] buf = new byte[8192];
int n;
while ((n = in.read(buf)) > 0) {
out.write(buf, 0, n);
}
}
NIO 방식 (빠름):
try (FileChannel srcCh = FileChannel.open(src, READ);
FileChannel destCh = FileChannel.open(dest, WRITE, CREATE)) {
srcCh.transferTo(0, srcCh.size(), destCh);
// zero-copy 활용 (OS 지원 시)
}
NIO.2 방식 (간결):
Files.copy(src, dest);
// 한 줄시나리오 3: 대규모 동시 서버
IO 방식 (제한):
- 1 연결 = 1 스레드
- 1만 연결 = 1만 스레드
- 메모리 부담
NIO 방식 (대규모):
- Selector + Non-blocking
- 한 스레드로 1만 연결
- Netty 같은 라이브러리 권장
실무:
- Spring WebFlux (Reactor + Netty)
- 또는 Vert.x
- 또는 Project Loom (Java 21+ 가상 스레드)시나리오 4: 직렬화
여전히 IO 사용:
ObjectOutputStream oos = new ObjectOutputStream(
new FileOutputStream("data.dat"));
oos.writeObject(shipment);
NIO.2 와 결합:
try (OutputStream os = Files.newOutputStream(Path.of("data.dat"));
ObjectOutputStream oos = new ObjectOutputStream(os)) {
oos.writeObject(shipment);
}
// Files.newOutputStream 으로 시작, 안은 IO
직렬화는 Unit 9.4 에서 정밀8.3 라이브러리 의존성
실무 라이브러리:
Apache Commons IO:
- IOUtils.copy, IOUtils.toString
- 편의 유틸리티
- IO 시대의 산물이지만 여전히 유용
Guava (Google):
- Files.toString (deprecated, Files.readString 권장)
- ByteStreams, CharStreams
Spring:
- FileSystemResource, ClassPathResource
- 추상화 자원
Netty:
- Non-blocking 네트워크의 표준
- Reactor, gRPC 의 토대8.4 운영 환경 고려
운영 시 고려할 점:
1. 파일 시스템 추상화 (NIO.2)
- ZIP, 메모리, 네트워크 FS
- 동일 코드로 다양한 FS
2. 비동기 I/O (NIO/NIO.2)
- CompletableFuture 활용
- 스레드 효율
3. 자원 관리
- try-with-resources 필수
- AutoCloseable 의 우아한 처리
4. 모니터링
- I/O 시간 측정
- 슬로우 작업 추적
5. 에러 처리
- 명확한 예외 (NIO.2)
- 재시도 로직8.5 ILIC 의 종합 활용
@Service
public class ShipmentIoService {
private final Path baseDir = Path.of("/var/shipment");
// 1. NIO.2 — 일반 파일 작업
public void exportCsv(List<Shipment> shipments, String filename) throws IOException {
Path file = baseDir.resolve(filename);
Files.createDirectories(file.getParent());
try (BufferedWriter writer = Files.newBufferedWriter(file)) {
writer.write("id,blNo,weight\n");
for (Shipment s : shipments) {
writer.write(s.toCsvLine());
writer.newLine();
}
}
}
// 2. NIO — 고속 복사
public void copyToBackup(Path src) throws IOException {
Path backup = baseDir.resolve("backup").resolve(src.getFileName());
Files.createDirectories(backup.getParent());
try (FileChannel srcCh = FileChannel.open(src, StandardOpenOption.READ);
FileChannel destCh = FileChannel.open(backup,
StandardOpenOption.CREATE, StandardOpenOption.WRITE)) {
srcCh.transferTo(0, srcCh.size(), destCh);
}
}
// 3. IO — 직렬화
public void saveAsBinary(Shipment shipment, String name) throws IOException {
Path file = baseDir.resolve(name);
try (OutputStream os = Files.newOutputStream(file);
ObjectOutputStream oos = new ObjectOutputStream(os)) {
oos.writeObject(shipment);
}
}
// 4. NIO.2 + Stream — 통계
public long countLargeFiles(long thresholdBytes) throws IOException {
try (Stream<Path> files = Files.walk(baseDir)) {
return files
.filter(Files::isRegularFile)
.filter(p -> {
try {
return Files.size(p) > thresholdBytes;
} catch (IOException e) {
return false;
}
})
.count();
}
}
// 5. NIO.2 + WatchService — 디렉토리 감시
@PostConstruct
public void watchDirectory() throws IOException {
WatchService watcher = FileSystems.getDefault().newWatchService();
baseDir.register(watcher,
StandardWatchEventKinds.ENTRY_CREATE);
new Thread(() -> {
while (true) {
try {
WatchKey key = watcher.take();
key.pollEvents().forEach(event -> {
Path path = (Path) event.context();
log.info("New file: {}", path);
});
if (!key.reset()) break;
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
return;
}
}
}).start();
}
}8.6 자기 점검 답변
실무에서 IO/NIO/NIO.2 선택 기준은?
답:
1. NIO.2 (java.nio.file) 기본:
- 새 코드
- 파일 작업
- Stream 활용
-
NIO (java.nio):
- 대규모 네트워크
- DirectBuffer
- zero-copy
-
IO (java.io):
- 직렬화 (ObjectStream)
- Reader/Writer 텍스트
- 레거시 호환
-
결합:
- NIO.2 의 newInputStream/newOutputStream 으로 IO 와 결합
- 동시 활용 가능
→ 한 시스템에서 셋 모두 사용 가능.
9️⃣ 면접 + 자기 점검
9.1 면접 단골 질문 매핑
| Q | 핵심 답변 |
|---|---|
| IO/NIO/NIO.2 차이? | 스트림 vs 채널+버퍼 vs Path+Files |
| 등장 버전? | 1.0 / 1.4 / 7 |
| IO 의 5가지 한계? | 1바이트, 단방향, Blocking, Decorator, File |
| Channel 의 효과? | 양방향, 블록 단위 |
| Buffer 의 4속성? | capacity, position, limit, mark |
| Selector? | 한 스레드로 다수 채널 |
| File vs Files? | 인스턴스 vs static, 진단 |
| NIO.2 의 추가? | Path, Files, WatchService, Async |
| Stream 통합? | Files.lines, walk |
| 어느 것을 언제? | 파일 NIO.2, 네트워크 대규모 NIO, 직렬화 IO |
| Decorator 패턴? | 기본 + 보조 스트림 중첩 |
9.2 자기 점검 체크리스트
IO (java.io)
- 스트림 기반 구조
- 바이트 vs 문자 스트림
- Decorator 패턴
- 5가지 한계
NIO (java.nio)
- Channel 의 정의
- Buffer 의 구조
- Selector 의 역할
- zero-copy (transferTo)
- DirectBuffer
NIO.2 (java.nio.file)
- Path 와 Files
- WatchService
- AsynchronousChannel
- FileSystem 추상화
- Stream 통합
비교
- 3 시대 차이
- 단방향 vs 양방향
- Blocking vs Non-blocking
- File vs Files
실무
- 선택 기준
- 라이브러리 의존
- 결합 활용
- 모니터링
9.3 추가 심화 질문
Q1: NIO 가 무조건 더 빠른가?
답:
- 아니다.
- NIO 는 대규모 동시 연결 에서 유리
- 단순한 단일 파일 작업은 IO/NIO.2 가 더 빠를 수 있음
- 이유:
- Buffer 관리 비용
- 직접 메모리 할당/해제 비용
- 작은 파일은 NIO 의 이점 적음
Q2: Direct Buffer 의 장단점?
답:
// Direct Buffer
ByteBuffer direct = ByteBuffer.allocateDirect(1024);
장점:
- JVM heap 밖의 메모리
- I/O 호출 시 복사 불필요 (zero-copy)
- 네트워크 I/O 빠름
단점:
- 할당/해제 비용 큼
- GC 가 직접 정리 안 함 (Cleaner 사용)
- 메모리 누수 가능
- 적합한 용도: 큰 데이터, 자주 재사용Q3: WatchService 의 한계?
답:
- 운영체제 의존 (Linux inotify, macOS fsevents 등)
- 일부 OS 는 폴링 사용 (느림)
- 매우 빈번한 변경 시 이벤트 손실 가능
- 큰 디렉토리에서 성능 저하
대안:
- Apache Commons IO 의 FileAlterationMonitor
- 사용자 정의 폴링
Q4: Files.lines 와 BufferedReader 의 차이?
답:
// Files.lines — Stream
try (Stream<String> lines = Files.lines(path)) {
lines.forEach(System.out::println);
}
// BufferedReader — 전통
try (BufferedReader br = Files.newBufferedReader(path)) {
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
}
차이:
- Files.lines: 함수형, Stream 활용
- BufferedReader: 명령형, 전통
- 성능: 비슷 (내부 동일)
- 가독성: Files.lines 가 짧음
- 처리: Stream API 활용 시 Files.linesQ5: 비동기 I/O 가 항상 좋은가?
답:
-
아니다.
-
비동기는 다음 시나리오에 적합:
- 대규모 동시 I/O
- I/O bound 작업
- 마이크로서비스
-
부적합:
- CPU bound 작업
- 단순한 스크립트
- 디버깅이 중요한 경우
- 코드 가독성이 우선인 경우
-
대안 (Java 21+):
- Project Loom 의 가상 스레드
- 동기 코드의 단순함 + 비동기의 효율
🎯 핵심 요약 — 3줄 정리
1. 자바 I/O 3 시대
- IO (1.0): 스트림, 1바이트, 단방향, Blocking
- NIO (1.4): 채널+버퍼, 양방향, Non-blocking
- NIO.2 (7): Path+Files, Stream 통합, Async
2. 결정적 차이 4가지
- 단위: 스트림 → 채널+버퍼
- 방향: 단방향 → 양방향
- 동기: Blocking → Non-blocking
- 파일: File → Files (static)
3. 실무 선택
- 파일 일반: NIO.2 (Files)
- 대규모 네트워크: NIO (Channel + Selector)
- 직렬화/레거시: IO
- 셋 다 공존 + 결합 가능
📚 다음으로...
Unit 7.3 — Stream vs Channel
이번 Unit에서 IO/NIO 의 큰 그림을 봤다면, 다음은 Stream 과 Channel 의 정밀 비교.
- Stream (IO) 의 정확한 구조
- Channel (NIO) 의 양방향
- Buffer 의 정밀 (position/limit/capacity)
- 두 가지의 성능 차이
- 언제 어느 것을
Phase 7 진행 상황
🚀 Phase 7 — I/O 시스템 큰 그림
✅ Unit 7.1 I/O 란 무엇인가
✅ Unit 7.2 IO vs NIO (역사적 진화) ← 여기
⏭ Unit 7.3 Stream vs Channel
⏭ Unit 7.4 Blocking vs Non-blocking (★ 마스터 깊이)
⏭ Unit 7.5 오버헤드와 File 객체3주차 누적 진행
✅ Phase 1 — Pass by Value (1.1 ~ 1.3 완주)
✅ Phase 2 — 컬렉션 프레임워크 (2.1 ~ 2.6 완주)
✅ Phase 3 — 해시의 원리 (3.1 ~ 3.4 완주)
✅ Phase 4 — 추상화의 두 도구 (4.1 ~ 4.4 완주)
✅ Phase 5 — 제네릭과 와일드카드 (5.1 ~ 5.5 완주)
✅ Phase 6 — 객체 비교 (6.1 ~ 6.4 완주)
🚀 Phase 7 — I/O 시스템 큰 그림 (2/5 진행)
총: 28/43 Unit 작성 (약 65%)
Software Developer