Chunk 단위 처리와 OOM 방지

JVM 힙 (-Xmx 로 상한)
┌───────────────────────────────────────────────────────┐
│ Young (Eden + Survivor)     │ Old                     │
│ 새 객체가 태어나는 곳         │ 오래 살아남은 객체        │
│ 짧게 살고 죽으면 Minor GC 로 │ readAllLines 의 List 는  │
│ 빠르게 회수                  │ 계속 참조되어 여기 쌓임   │
└───────────────────────────────────────────────────────┘
   청크 처리: 청크 객체는 Young 에서 태어나 청크 끝에 죽음 → Old 로 안 감 → 힙 일정
   전체 로딩: 모두 살아있음 → Old 가 차오름 → Full GC 반복 → OOM

java -Xmx32m Main 1000000        # 힙 32MB 로 100만 행

                 ┌──────────────── 반복 ────────────────┐
                 ▼                                        │
   reader.read() × N  ──▶  List<I> chunk (N건)           │
                             │                            │
                             ▼ processor.process() × N    │
                           List<O> outs                   │
                             │                            │
                             ▼ writer.write(outs)   ◀── 커밋 포인트
                             │                            │
                    chunk, outs 참조 해제 ──▶ 다음 GC 에서 회수
                                                          │
                 (reader 가 null 반환할 때까지) ──────────┘

   힙 사용량:  ▁▂▃▁▂▃▁▂▃▁▂▃  (청크마다 오르내림, 상한 일정)
   전체 로딩:  ▁▂▃▄▅▆▇█ OOM

처리량
  ▲                 ┌───── 평탄 (I/O 오버헤드가 이미 무시할 수준)
  │           ┌─────┘
  │      ┌────┘
  │  ┌───┘
  │──┘
  └────────────────────────────▶ 청크 크기
     1   10  100  1000  10000
                 ▲
             여기부터는 커져도 이득이 거의 없고 위험만 커짐

hasNext(): nextLine 이 비어 있으면 readLine() 으로 채운다 → null 이면 false
next():    nextLine 을 돌려주고 비운다

-- offset 방식: 페이지가 뒤로 갈수록 느려진다
SELECT * FROM orders ORDER BY id LIMIT 1000 OFFSET 990000;
--  → DB 는 991,000 행을 읽고 990,000 행을 버린다. 100만 건이면 마지막 페이지가 첫 페이지보다 1000배 느림

-- 키셋(keyset, seek) 방식: 항상 같은 속도
SELECT * FROM orders WHERE id > :lastId ORDER BY id LIMIT 1000;
--  → 인덱스에서 lastId 다음부터 1000행만 읽는다. 마지막 처리한 id 를 기억하면 재시작도 쉽다

class KeysetReader implements ItemReader<Order> {
    long lastId = 0;
    Deque<Order> page = new ArrayDeque<>();
    public Order read() {
        if (page.isEmpty()) {
            page.addAll(dao.findAfter(lastId, 1000));   // WHERE id > ? ORDER BY id LIMIT 1000
            if (page.isEmpty()) return null;
        }
        Order o = page.poll();
        lastId = o.id();
        return o;
    }
}

while (true) {
    List<I> chunk = readChunk(reader);   // 루프 지역 변수
    ...
    writer.write(outs);
}                                         // chunk, outs 스코프 종료 → 참조 없음 → 회수 가능

[progress] chunk#250  read=250,000  1,180,000 items/s  ETA 0s  (25.0%)

  Reader (1 thread)  ──chunk1──▶ [worker 1]  process+write
   순차 읽기          ──chunk2──▶ [worker 2]  process+write
                     ──chunk3──▶ [worker 3]  process+write
                     ──chunk4──▶ (Semaphore 대기: in-flight 한도 초과)