정적 분석 도구 활용
코드를 실행하지 않고 소스·바이트코드를 분석해 버그, 코드 냄새, 보안 취약점을 미리 찾아내는 정적 분석을 다룹니다. SpotBugs·PMD·Error Prone·SonarQube의 역할 구분, shift-left로 수정 비용을 낮추는 원리, 그리고 오탐 관리와 CI 통합 전략까지 정리합니다.
일치하는 글이 없습니다.
293개의 글이 있습니다.
코드를 실행하지 않고 소스·바이트코드를 분석해 버그, 코드 냄새, 보안 취약점을 미리 찾아내는 정적 분석을 다룹니다. SpotBugs·PMD·Error Prone·SonarQube의 역할 구분, shift-left로 수정 비용을 낮추는 원리, 그리고 오탐 관리와 CI 통합 전략까지 정리합니다.
코드는 쓰이는 시간보다 읽히는 시간이 훨씬 길다는 전제에서 출발해, 자바의 명명 규칙과 포매팅 관례를 정리합니다. 나아가 사람의 규율이 아니라 EditorConfig·Spotless·Checkstyle·CI로 이어지는 자동화 계층으로 일관성을 강제하는 방법을 다룹니다.
동작하는 레거시 시스템을 멈추지 않고 현대화하는 방법을 다룹니다. 특성화 테스트로 안전망을 먼저 만들고, 스트랭글러 패턴으로 파사드를 두어 레거시를 조금씩 신규 코드로 대체하는 점진적 현대화 전략을 실전 코드와 함께 정리합니다.
Java 마이그레이션에서 반복적으로 마주치는 폐기·제거된 API를 한데 모아 정리합니다. @Deprecated의 생명주기(폐기 예고 → forRemoval → 제거), jdeprscan 진단, Thread.stop·finalize·SecurityManager·Date 등 주요 항목의 대체 방법을 실전 코드와 함께 다룹니다.
가상 스레드라는 동시성 패러다임 변화를 담은 Java 17 → 21 마이그레이션을 다룹니다. 새로 정식화된 기능(가상 스레드·switch 패턴 매칭·레코드 패턴·순차 컬렉션), 가상 스레드 도입 시 재검토할 관행(스레드 풀·synchronized·ThreadLocal), 단계별 이동 전략을 정리합니다.
LTS에서 LTS로 이동하는 비교적 매끄러운 구간인 Java 11 → 17 마이그레이션을 다룹니다. 강한 캡슐화(JEP 396)로 인한 내부 API 차단 대응, 새로 정식화된 언어 기능(records·sealed·switch 표현식·text blocks), 최신 GC 도입을 실전 관점에서 정리합니다.
가장 널리 쓰이던 Java 8에서 첫 모듈형 LTS인 Java 11로 이동하는 실전 가이드입니다. JDK에서 제거된 Java EE 모듈(JAXB·JAX-WS 등) 복구, 내부 API 접근 제한, jdeps 진단, 점진적 마이그레이션 순서를 코드와 함께 정리합니다.
Java native 역직렬화가 왜 위험한지, 가젯 체인이 어떻게 원격 코드 실행으로 이어지는지 이해하고, ObjectInputFilter(JEP 290) 기반 허용 목록 필터링과 데이터 전용 포맷 전환 같은 방어 전략을 실전 코드로 정리합니다.
신뢰 경계와 입력 검증의 원칙을 이해하고, SQL 인젝션·경로 순회·명령어 삽입 같은 인젝션 공격을 Java 코드에서 막는 방법을 다룹니다. 허용 목록 검증, PreparedStatement, Bean Validation, 경로 정규화 등 실전 방어 기법을 정리합니다.
JWT(JSON Web Token)의 구조와 토큰 기반 인증의 원리를 이해하고, jjwt 라이브러리로 토큰을 발급·검증하는 코드를 작성합니다. 서명 알고리즘 선택, 만료·클레임 검증, alg=none 공격 방어 등 실무에서 반드시 지켜야 할 보안 원칙을 정리합니다.
Java에서 TLS로 전송 구간을 보호하는 방법을 다룹니다. TLS 핸드셰이크의 흐름, KeyStore와 TrustStore의 차이, keytool로 인증서를 관리하는 법, JSSE로 HTTPS 클라이언트를 구성하고 인증서 검증을 올바르게 다루는 실전 코드를 정리합니다.
Java Cryptography Architecture(JCA)의 프로바이더 기반 설계를 이해하고, 해시(MessageDigest), 대칭 암호(Cipher, AES-GCM), 비대칭 암호(RSA, Signature)를 실제 코드로 구현합니다. 암호 프리미티브 3종의 용도 차이와 안전한 사용법을 정리합니다.
Java 애플리케이션 보안의 전체 지형을 조망합니다. JVM 플랫폼 보안, JCA 암호화, 입력·데이터 보안, 인증·인가 계층으로 이어지는 심층 방어 구조와 기밀성·무결성·가용성(CIA) 3대 목표, 그리고 앞으로 다룰 주제를 정리합니다.
자바와 Kotlin은 같은 바이트코드로 컴파일되어 한 프로젝트에서 서로를 자유롭게 호출합니다. 양방향 호출의 원리, getter/setter와 프로퍼티의 대응, 플랫폼 타입과 null, companion·@JvmStatic 같은 마찰점, 그리고 점진적 도입 전략을 정리합니다.
Scala는 객체지향과 함수형을 강력한 타입 시스템 위에서 융합한 JVM 언어입니다. 표현식 중심 스타일, 불변성, 패턴 매칭, 트레이트 같은 핵심 특징을 자바와 비교하고, 표현력과 학습 곡선의 무게를 함께 따져 선택 기준을 정리합니다.
Kotlin은 자바의 장황함을 덜고 널 안전성을 타입에 새긴 현대적 JVM 언어입니다. 간결한 데이터 클래스, 널 안전성, 확장 함수, 코루틴 같은 핵심 차이를 자바와 나란히 비교하고, 둘 중 무엇을 선택할지 판단 기준을 정리합니다.
JVM은 자바만의 것이 아닙니다. Kotlin·Scala·Groovy·Clojure 등 여러 언어가 같은 바이트코드로 컴파일되어 하나의 JVM 위에서 동작합니다. JVM 언어가 존재하는 이유, 공유하는 자산, 그리고 대표 언어들의 성격을 조망합니다.
gRPC는 .proto 계약에서 클라이언트·서버 코드를 생성하고, Protocol Buffers 바이너리를 HTTP/2로 주고받는 고성능 RPC 프레임워크입니다. RPC의 개념, proto 계약과 코드 생성, 네 가지 호출 방식, REST와의 비교를 정리합니다.
WebSocket은 한 번 연결을 열어 두고 서버와 클라이언트가 양방향으로 메시지를 주고받는 프로토콜입니다. 요청-응답 HTTP의 한계, HTTP Upgrade 핸드셰이크, Java 11 java.net.http의 WebSocket과 Listener 콜백 모델을 정리합니다.
Java 11에 표준으로 들어온 HttpClient는 빌더 기반 API, HTTP/2 지원, 동기·비동기 호출을 모두 갖춘 현대적 HTTP 클라이언트입니다. HttpClient·HttpRequest·HttpResponse의 역할, BodyHandlers, send와 sendAsync의 차이를 정리합니다.
HttpURLConnection은 외부 의존성 없이 HTTP를 호출하는 자바의 전통적 API입니다. HTTP 메시지의 구조, openConnection부터 응답 읽기까지의 4단계, GET·POST 호출법, 그리고 이 API의 오래된 불편함과 Java 11 HttpClient로의 전환 배경을 정리합니다.
ServerSocket은 특정 포트에서 연결을 기다리다 수락하는 서버 측 소켓입니다. bind·accept의 생애주기, accept()가 연결마다 새 Socket을 돌려주는 원리, 연결당 스레드 모델로 여러 클라이언트를 동시에 처리하는 구조까지 정리합니다.
소켓은 두 프로그램이 네트워크 너머로 바이트를 주고받는 양 끝점입니다. TCP 소켓의 개념, Socket 클래스로 연결을 맺고 입력·출력 스트림으로 데이터를 주고받는 흐름, 그리고 자바 네트워킹의 토대가 되는 핵심 개념을 정리합니다.
MyBatis는 SQL을 직접 작성하되 파라미터 바인딩과 결과 매핑의 반복만 덜어주는 SQL 매퍼입니다. 매퍼 인터페이스와 XML 매핑, 동적 SQL, JDBC·JPA·jOOQ 사이에서의 위치, 그리고 선택 기준까지 정리하며 데이터 접근 묶음을 마무리합니다.
jOOQ는 SQL을 숨기지 않고 자바 코드로 직접 작성하되 컴파일 타임 타입 안전성을 더하는 라이브러리입니다. 코드 생성 기반 동작, 문자열 SQL과의 차이, JPA와의 철학적 대비, 그리고 언제 jOOQ가 적합한지를 정리합니다.
Hibernate는 JPA 명세를 가장 널리 구현한 ORM 엔진입니다. 엔티티의 네 가지 생명주기 상태, 지연 로딩과 N+1 문제, 더티 체킹과 플러시, 그리고 Hibernate를 실무에서 잘 쓰기 위한 핵심 감각을 정리합니다.
JPA는 자바 객체와 관계형 테이블을 매핑하는 ORM 표준입니다. 객체-관계 임피던스 불일치 문제, 명세와 구현(Hibernate)의 관계, 엔티티와 영속성 컨텍스트, 그리고 JPA가 주는 이득과 대가를 균형 있게 정리합니다.
커넥션 풀은 DB 연결을 미리 만들어 두고 빌려주고 돌려받아 연결 생성·해제 비용을 없앱니다. 연결이 비싼 이유, DataSource 추상화, HikariCP 설정의 핵심 파라미터, 풀 고갈과 연결 누수까지 실무 관점으로 정리합니다.
배치 처리는 여러 SQL을 모아 한 번의 네트워크 왕복으로 전송해 대량 처리 성능을 끌어올립니다. addBatch·executeBatch 패턴, 청크 단위 flush, rewriteBatchedStatements 같은 드라이버 옵션, 그리고 흔한 함정까지 정리합니다.
트랜잭션은 여러 SQL을 '전부 성공하거나 전부 취소'되는 하나의 작업 단위로 묶습니다. JDBC의 autoCommit 동작, setAutoCommit·commit·rollback 패턴, try-with-resources와의 조합, 격리 수준까지 실무 관점으로 정리합니다.
PreparedStatement는 SQL 구조와 값을 분리해 SQL 인젝션을 원천 차단하고, 사전 컴파일로 성능까지 챙기는 JDBC의 표준 도구입니다. Statement와의 차이, 값 바인딩 원리, 흔한 오해와 한계까지 정리합니다.
JDBC는 자바 애플리케이션이 관계형 데이터베이스에 접근하는 표준 API입니다. 표준 인터페이스와 벤더별 드라이버의 분리 구조, Connection·Statement·ResultSet의 다섯 단계 흐름, try-with-resources를 이용한 자원 정리까지 기본기를 정리합니다.
MDC(Mapped Diagnostic Context)는 한 요청에 속한 모든 로그를 같은 식별자로 묶어 분산된 로그 속에서 흐름을 추적하게 해줍니다. ThreadLocal 기반 동작 원리, SLF4J·Logback에서의 설정, 스레드 풀 누수와 비동기 전파 문제까지 정리합니다.
java.util.logging은 외부 의존성 없이 JDK에 내장된 로깅 API입니다. Logger·Handler·Formatter 구조, 낯선 레벨 체계, logging.properties 설정, SLF4J와의 연결, 그리고 언제 쓰고 언제 피해야 하는지를 정리합니다.
2021년 인터넷 전체를 뒤흔든 Log4Shell(CVE-2021-44228)은 로그에 찍힌 문자열만으로 원격 코드 실행을 일으켰습니다. JNDI 룩업이라는 기능이 어떻게 무기가 됐는지, 그리고 업그레이드를 비롯한 올바른 대응을 정리합니다.
Log4j 2는 Disruptor 기반 비동기 로깅과 가비지 프리 모드로 높은 처리량을 제공하는 로깅 구현입니다. 아키텍처, log4j2.xml 설정, 비동기 로깅 원리, Logback과의 선택 기준을 정리합니다.
Logback은 SLF4J 제작자가 만든 로깅 구현으로 스프링 부트의 기본값입니다. Logger·Appender·Encoder의 구조, logback.xml 설정, 롤링 파일 정책, 그리고 운영에서 중요한 패턴 레이아웃과 비동기 출력을 정리합니다.
SLF4J는 자바 로깅의 사실상 표준 파사드입니다. 컴파일타임 API와 런타임 바인딩의 구조, 중괄호 플레이스홀더의 성능 이점, 브리지로 레거시 로그를 모으는 법, 그리고 흔한 바인딩 충돌 문제를 정리합니다.
자바 로깅은 JUL, Log4j, Logback, SLF4J가 얽힌 복잡한 역사를 가졌습니다. 파사드와 구현의 분리, 로그 레벨, 왜 직접 println을 쓰면 안 되는지, 그리고 생태계 전체 지형을 정리해 이후 글들의 토대를 놓습니다.
커버리지는 코드 실행 여부만 셀 뿐 단언의 품질은 보지 못합니다. 뮤테이션 테스트는 코드를 일부러 변형해 테스트가 그 변형을 잡아내는지 확인합니다. PIT(pitest)의 원리와 설정, 뮤테이션 점수 해석을 정리합니다.
커버리지는 테스트가 코드를 얼마나 실행했는지 보여 주는 지표입니다. JaCoCo의 계측 원리, 라인·브랜치 커버리지의 차이, 빌드 게이트 설정, 그리고 커버리지 숫자를 맹신하면 안 되는 이유까지 정리합니다.
레이어 의존성 규칙은 문서에만 적어 두면 시간이 지나며 무너집니다. ArchUnit으로 패키지 의존 방향, 네이밍 규칙, 순환 참조 금지를 단위 테스트처럼 검증하고 CI에서 자동으로 강제하는 법을 정리합니다.
인메모리 DB로는 운영 환경을 완벽히 흉내 낼 수 없습니다. Testcontainers로 실제 PostgreSQL·Kafka·Redis 컨테이너를 테스트 안에서 띄우고, JUnit 5 통합과 자동 정리, 컨테이너 재사용까지 정리합니다.
JUnit의 기본 단언은 표현력에 한계가 있습니다. AssertJ의 assertThat 체이닝으로 대상을 먼저 읽고, 문자열·컬렉션·예외·객체를 풍부하게 검증하며, 실패 메시지까지 명확해지는 유창한 단언을 정리합니다.
기본을 넘어선 Mockito의 진짜 힘은 인자 매처, 연속 응답, ArgumentCaptor, BDD 스타일에 있습니다. any·eq 매처 규칙과 흔한 함정, 그리고 전달된 인자를 붙잡아 검증하는 기법까지 정리합니다.
단위 테스트는 협력 객체를 가짜로 대체해 대상만 격리해야 합니다. Mockito의 Mock·Stub·Spy 개념, @Mock과 @InjectMocks, when().thenReturn()과 verify()로 외부 의존성 없이 테스트하는 법을 정리합니다.
같은 검증을 여러 입력값으로 반복할 때 테스트를 복사하지 마세요. @ParameterizedTest와 @ValueSource·@CsvSource·@MethodSource로 입력만 바꿔 가며 한 메서드로 다양한 케이스를 검증하는 방법을 정리합니다.
테스트는 서로 독립적이어야 합니다. @BeforeEach·@AfterEach로 매 테스트를 준비·정리하고 @BeforeAll·@AfterAll로 비싼 자원을 공유하는 방법, 그리고 테스트 인스턴스 생명주기까지 정리합니다.
JUnit 5는 자바 단위 테스트의 사실상 표준입니다. Platform·Jupiter·Vintage 세 모듈 구조, @Test와 Assertions의 기본 사용법, @DisplayName과 assertThrows까지 JUnit 5의 시작을 정리합니다.
여러 라이브러리의 버전을 일일이 맞추다 보면 충돌과 비호환이 생깁니다. BOM(Bill of Materials)으로 호환되는 버전 묶음을 한 번에 선언하고, Maven dependencyManagement와 Gradle platform으로 적용하는 방법을 정리합니다.
프로젝트가 커지면 하나의 거대한 모듈은 빌드와 유지보수를 어렵게 만듭니다. 멀티 모듈 빌드로 domain·service·web을 분리하고, settings.gradle.kts와 project() 의존으로 모듈을 조립하는 방법을 정리합니다.
Maven과 Gradle은 자바 빌드 도구의 양대 산맥입니다. 설정 언어, 빌드 모델, 증분 빌드와 캐시, 학습 곡선, 빌드 속도까지 두 도구의 차이를 정리하고 프로젝트 상황별 선택 기준을 제시합니다.
Gradle 빌드는 Task의 모임입니다. 초기화·구성·실행 3단계, Task의 입출력 선언과 증분 빌드, doLast와 dependsOn으로 커스텀 Task를 만드는 방법까지 Gradle Task의 작동 원리를 정리합니다.
Gradle은 선언형과 명령형을 결합한 빌드 도구입니다. Task DAG, Kotlin DSL, Gradle Wrapper, 증분 빌드와 빌드 캐시까지 — Maven과 다른 Gradle의 핵심 개념과 기본 사용법을 정리합니다.
Maven의 모든 기능은 플러그인으로 구현됩니다. 플러그인이란 무엇이고 Goal·Phase와 어떻게 연결되는지, pom.xml에서 어떻게 설정하는지, 그리고 실무에서 자주 쓰는 플러그인들을 정리합니다.
Maven의 3대 빌드 라이프사이클(clean, default, site)과 default 라이프사이클의 주요 페이즈 흐름, 페이즈와 플러그인 골의 관계, 패키징 타입에 따른 기본 바인딩, 페이즈와 골의 실행 방식 차이를 정리합니다.
Maven이 무엇인지, 왜 쓰는지부터 pom.xml 구조, 표준 디렉토리 레이아웃, 로컬 저장소, 전이 의존성, 기본 명령어까지 자바 빌드의 표준 도구 Maven을 처음부터 정리합니다.
Native Image의 빠른 기동·낮은 RSS 장점과 긴 빌드·리플렉션 제약·낮은 피크 처리량 단점을 정리하고, 서버리스·CLI·장기 실행 API 서버 등 워크로드별로 GraalVM을 언제 쓰고 언제 피해야 하는지 결정 기준을 제시합니다.
Truffle 프레임워크와 Polyglot API를 중심으로 GraalVM이 어떻게 JS·Python·Ruby를 JVM 위에서 실행하는지, 언어 간 객체를 직렬화 없이 공유하는 원리와 실제 Java 임베딩 코드를 정리합니다.
AOT와 JIT의 근본적 차이, 폐쇄 세계 AOT가 포기하는 것과 얻는 것, 피크 처리량을 되찾는 PGO, JIT 추측적 최적화와의 관계, 제거된 jaotc와 Project Leyden의 방향, AOT가 실제로 유리한 상황을 정리합니다.
native-image 도구가 바이트코드를 독립 실행 파일로 변환하는 원리를 살펴봅니다. 폐쇄 세계 가정, 포인트-투 분석, 힙 스냅샷, AOT 컴파일 단계와 리플렉션·JNI·리소스를 위한 도달 가능성 메타데이터 등록 방법을 정리합니다.
GraalVM이 무엇인지, Graal JIT 컴파일러가 HotSpot C2를 어떻게 대체하는지, JVMCI·Truffle 프레임워크·Native Image의 관계, Community/Oracle/Mandrel 배포판 차이, 그리고 언제 GraalVM을 선택해야 하는지 정리합니다.
JVM이 왜 느리게 시작하는지 클래스 로딩·인터프리터·JIT 워밍업 원리부터 짚고, CDS/AppCDS·Tiered Compilation·Lazy Init·클래스패스 최소화까지 실전 최적화 기법을 정리합니다.
async-profiler는 perf_events와 AsyncGetCallTrace를 이용한 샘플링 프로파일러로, 세이프포인트 편향 없이 1~2%대의 낮은 오버헤드로 CPU·할당·락을 분석합니다. 인스트루먼테이션과의 차이, 플레임그래프 읽는 법, 기본 사용법을 정리합니다.
CDS는 파싱·검증이 끝난 클래스 메타데이터를 아카이브 파일에 저장해 여러 JVM이 메모리 매핑으로 공유하게 함으로써 기동 시간과 메모리 사용을 줄입니다. 기본 CDS와 AppCDS, 동적 아카이브 생성 흐름을 정리합니다.
JVM 옵션은 표준·-X·-XX 세 계층으로 나뉩니다. 각 계층의 안정성과 의미, -XX의 Boolean·Value 형태, PrintFlagsFinal로 실제 적용값을 확인하는 법, 그리고 검증 없는 플래그 변경의 위험을 정리합니다.
JMH(Java Microbenchmark Harness)는 웜업·측정 반복과 다중 포크, Blackhole·@State로 데드코드 제거와 상수 폴딩을 막아 정확한 성능 측정을 돕습니다. 손으로 짠 벤치마크가 틀리는 이유와 JMH 기본 사용법을 정리합니다.
루프 언롤링은 반복문의 본문을 여러 번 복제해 종료 검사 횟수를 줄이고 명령어 수준 병렬성과 벡터화의 발판을 마련하는 JIT 최적화입니다. 동작 원리와 효과, 그리고 우리가 직접 손으로 펼치면 안 되는 이유를 정리합니다.
String Deduplication은 내용이 같은 여러 String 객체가 하나의 내부 배열을 공유하도록 만들어 힙 메모리를 절약하는 G1 GC 기능입니다. 동작 원리와 활성화 방법, 그리고 String 인터닝·중복 제거의 차이를 정리합니다.
이스케이프 분석은 객체가 메서드 밖으로 새어 나가는지 판별해 스택 할당, 스칼라 치환, 락 제거 같은 강력한 최적화를 가능하게 합니다. NoEscape·ArgEscape·GlobalEscape 분류와 스칼라 치환의 동작, 그리고 이 최적화를 깨뜨리지 않는 코딩 방법을 정리합니다.
JIT 컴파일러가 언제 어떤 메서드를 컴파일하는지 결정하는 호출 임계값과 단계형 컴파일을 살펴보고, PrintCompilation으로 컴파일 동작을 관찰하는 법, 그리고 섣부른 플래그 변경의 위험과 웜업의 중요성을 정리합니다.
애너테이션 프로세싱(APT)은 컴파일 중에 애너테이션을 읽어 새 소스를 생성하거나 규칙을 검증하는 메커니즘입니다. 라운드 기반 처리 모델, AbstractProcessor와 Filer·Messager, 그리고 Lombok·Dagger 같은 도구가 이를 어떻게 활용하는지 정리합니다.
@interface 키워드로 나만의 애너테이션을 선언하고, 요소(element)와 default, value의 특별 규칙을 정리합니다. 그리고 런타임 리플렉션으로 애너테이션을 읽어 동작을 분기하는 작은 벤치마크 러너를 직접 만들어 봅니다.
메타 애너테이션은 애너테이션에 붙는 애너테이션으로, 생존 기간과 적용 위치 같은 규칙을 정합니다. @Retention의 SOURCE/CLASS/RUNTIME, @Target의 적용 대상, @Documented와 @Inherited의 역할을 코드와 함께 정리합니다.
자바가 java.lang에서 기본 제공하는 세 내장 애너테이션을 정리합니다. @Override가 재정의 실수를 잡는 원리, @Deprecated의 since·forRemoval 요소, @SuppressWarnings의 올바른 사용 범위를 코드와 함께 다룹니다.
애너테이션은 코드의 동작을 바꾸지 않고 정보(메타데이터)만 덧붙이는 장치입니다. @interface로 직접 선언하는 법, 요소(element)와 기본값, 그리고 그 정보를 누가 어떻게 읽는지를 코드와 함께 정리합니다.
MethodHandle은 리플렉션의 느림을 극복하기 위해 자바 7에서 도입된 저수준 호출 메커니즘입니다. Lookup·MethodType·MethodHandle의 삼각 구조, invokeExact의 엄격함, 그리고 invokedynamic과의 관계를 코드와 함께 정리합니다.
java.lang.reflect.Proxy는 런타임에 인터페이스를 구현하는 객체를 만들고, 모든 메서드 호출을 InvocationHandler 한 곳으로 모읍니다. 로깅·트랜잭션·AOP의 토대가 되는 동적 프록시의 원리와 제약을 코드와 함께 정리합니다.
Field, Method, Constructor는 리플렉션으로 멤버를 조작하는 핵심 객체입니다. 필드 값 읽기·쓰기, 메서드 호출, 생성자로 객체 만들기, 그리고 setAccessible로 캡슐화를 넘는 법과 그 대가를 코드와 함께 정리합니다.
리플렉션은 컴파일 시점에 타입을 몰라도 런타임에 클래스 구조를 조회하고 조작하게 해 줍니다. Class 객체를 얻는 세 가지 방법, 필드·메서드·생성자 접근의 출발점, 그리고 리플렉션의 비용과 주의점을 코드와 함께 정리합니다.
기존 classpath 기반 애플리케이션을 JPMS 모듈로 점진 이행하는 방법을 정리합니다. unnamed module, automatic module, explicit module의 3단계 사다리와 상향식·하향식 전략, 그리고 실무에서 만나는 함정을 코드와 함께 다룹니다.
JMOD는 JAR가 담지 못하는 네이티브 라이브러리와 명령까지 포함하는 모듈 패키징 포맷입니다. JAR와의 차이, jmod 도구로 생성·조회하는 법, 그리고 jlink 입력으로서의 역할을 코드와 함께 정리합니다.
jlink는 애플리케이션이 실제로 쓰는 모듈만 골라 자체 실행 가능한 런타임 이미지를 만듭니다. 전체 JDK 없이도 돌아가는 작고 독립적인 배포본을 만드는 원리와 명령 옵션을 코드와 함께 정리합니다.
JPMS의 서비스 메커니즘은 인터페이스를 사이에 두고 구현 제공자(provides)와 소비자(uses)를 느슨하게 묶습니다. ServiceLoader가 런타임에 구현을 찾아 주입하는 원리와, 플러그인 구조를 모듈로 구현하는 법을 코드와 함께 정리합니다.
모듈 선언의 두 주역인 requires와 exports를 깊이 봅니다. requires의 transitive·static 변형이 무엇을 바꾸는지, exports와 한정 exports(... to)의 차이, exports와 opens의 경계까지 — 의존과 공개를 정밀하게 제어하는 법을 정리합니다.
module-info.java는 모듈의 정체를 선언하는 특별한 소스 파일입니다. 모듈 루트에 두는 위치 규칙, 모듈 이름 짓는 관례, requires·exports·opens·uses·provides 지시어의 역할, 그리고 컴파일과 실행 방법까지 모듈 선언의 기본기를 정리합니다.
Java 9의 모듈 시스템(JPMS, Project Jigsaw)은 classpath의 한계를 해결합니다. 강한 캡슐화로 internal 패키지를 숨기고, requires/exports로 의존성을 명시하며, 빠진 의존성을 시작 시점에 잡아냅니다. JPMS가 푸는 문제와 핵심 개념을 정리합니다.
JDK Mission Control(JMC)은 JFR 기록(.jfr)을 펼쳐 분석하는 GUI 도구입니다. Automated Analysis로 문제를 빠르게 짚고, 플레임 그래프로 CPU 핫스팟을, 할당 뷰로 GC 압력의 출처를, 락 뷰로 경합을 추적하는 실전 분석 흐름을 정리합니다.
JDK Flight Recorder(JFR)는 JVM에 내장된 초저오버헤드 이벤트 기록기입니다. 스레드-로컬 버퍼 구조로 약 1% 오버헤드만으로 GC·할당·락 경합·메서드 샘플을 상시 기록하고, jcmd로 .jfr을 떠 분석으로 넘기는 방법을 정리합니다.
스레드 덤프는 모든 스레드의 현재 상태와 스택을 찍은 사진입니다. jstack·jcmd로 덤프를 뜨고, BLOCKED/WAITING 상태와 락 정보(waiting to lock / locked)를 읽어 응답 지연·행(hang)·데드락의 원인을 짚어내는 실전 절차를 정리합니다.
힙 덤프는 특정 시점 힙 전체의 사진입니다. jcmd·jmap·HeapDumpOnOOM으로 .hprof를 뜨고, Eclipse MAT에서 shallow/retained heap과 dominator tree, leak suspect, GC root 경로로 어떤 객체가 왜 회수되지 않는지를 추적하는 실전 절차를 정리합니다.
OutOfMemoryError는 한 가지가 아닙니다. Java heap space·GC overhead limit·Metaspace·unable to create native thread·Direct buffer memory 등 메시지마다 터진 메모리 영역과 원인이 다릅니다. 메시지를 읽고 영역을 특정해 진단으로 이어가는 법을 정리합니다.
GC가 안전하게 메모리를 정리하려면 모든 애플리케이션 스레드를 멈춰야 합니다. 그 멈춤(Stop-The-World)이 왜 필요한지, safepoint와 TTSP가 무엇인지, 한 번의 pause가 어떤 비용으로 채워지는지, 그리고 STW를 줄이는 현실적인 방향을 정리합니다.
JDK 9의 Unified Logging(-Xlog)으로 GC 로그를 켜고, 한 줄을 해부해 GC id·원인·힙 변화·pause 시간을 읽으며, 처리량·p99 pause·allocation/promotion rate·Full GC 빈도로 흔한 문제 패턴을 진단하는 법을 정리합니다.
GC 튜닝의 3대 원칙(측정 먼저·한 번에 하나씩·목표 명확히)부터 처리량/지연/footprint 트레이드오프, 수집기 선택 기준(Parallel·ZGC·G1·Serial), -Xms=-Xmx 힙 사이징과 young 비율·Metaspace, MaxGCPauseMillis·GCTimeRatio·ParallelGCThreads·ConcGCThreads 같은 목표지향 플래그, allocation rate를 줄이는 코드 최적화, 흔한 안티패턴, 그리고 container-aware(UseContainerSupport·MaxRAMPercentage) 설정까지 실전 절차로 정리합니다.
Shenandoah는 Red Hat이 개발한 초저지연 수집기로, ZGC와 같은 목표를 다른 방식으로 풉니다. forwarding(Brooks) 포인터와 load/store 배리어로 객체 이동(compaction)까지 애플리케이션과 동시에 수행해, 정지 시간을 힙 크기와 무관하게 유지합니다. region 기반 구조, 페이즈 동작, 배리어 비용으로 인한 처리량 손해, 그리고 ZGC와의 비교를 정리합니다.
ZGC는 힙 크기와 무관하게 STW를 1ms 미만으로 유지하는 초저지연 수집기입니다. 64비트 컬러드 포인터로 객체 상태를 인코딩하고, 로드 배리어로 동시 relocation 중에도 일관성을 self-healing으로 유지합니다. mark·relocate·remap이 거의 모두 concurrent하게 도는 구조, ZPage 기반 힙, multi-mapping의 메모리 비용, JDK 15 production-ready와 JDK 21 Generational ZGC까지 정리합니다.
G1(Garbage-First)은 힙을 동일 크기 region으로 잘게 나누고 역할을 동적으로 부여해, 정지 시간 목표(-XX:MaxGCPauseMillis) 안에서 회수 이득이 큰 region부터 비우는 수집기입니다. region 모델, evacuation 기반 compaction, concurrent marking cycle, Mixed GC, Remembered Set과 SATB write barrier 비용, Humongous 객체 처리, 그리고 튜닝 포인트를 정리합니다.
CMS(Concurrent Mark-Sweep)는 old gen을 애플리케이션과 동시에 수집해 STW를 줄인 최초의 실용 collector입니다. 4단계 동작, concurrent의 대가(CPU 분할·write barrier·floating garbage), compaction을 하지 않아 생기는 단편화와 Concurrent Mode Failure, 그리고 JDK 9 deprecate·JDK 14 제거에 이르는 흥망을 정리합니다.
Parallel GC(Throughput Collector)가 여러 GC 스레드로 STW 구간을 단축해 처리량을 끌어올리는 원리, young/old 모두 병렬 수집하는 구조, UseParallelGC·ParallelGCThreads·UseAdaptiveSizePolicy·MaxGCPauseMillis·GCTimeRatio 튜닝, 그리고 지연 민감 서비스에는 부적합한 이유를 정리합니다.
HotSpot에서 가장 단순한 가비지 컬렉터인 Serial GC를 정리합니다. 단일 스레드로 mark·copy·compact를 수행하는 DefNew(Young)와 Tenured(Old)의 구조, 전 과정 STW, 장단점, 그리고 -XX:+UseSerialGC를 언제 써야 하는지 살펴봅니다.
대부분의 객체는 일찍 죽는다는 약한 세대 가설에서 출발해, Eden/Survivor로 나뉜 Young 세대, Copying을 쓰는 Minor GC, MaxTenuringThreshold 기반 승격, Mark-Compact류 Old 세대, 그리고 Card Table로 교차 세대 참조를 추적하는 원리까지 세대별 GC를 정리합니다.
도달 가능성으로 생존 객체를 표시하는 Mark, 죽은 객체를 회수하는 Sweep, 단편화를 없애는 Compact, 반쪽 힙을 쓰는 Copying까지 GC의 세 가지 기본 알고리즘과 처리량·단편화·메모리의 트레이드오프를 정리합니다.
GC가 객체의 생사를 판정하는 도달 가능성(reachability)과 GC Roots, Stop-The-World의 의미, 처리량과 지연 시간이라는 두 평가축, HotSpot GC 계보의 큰 그림을 정리합니다.
GC 챕터의 출발점으로 JVM 메모리 구조를 GC 관점에서 재정리합니다. Heap의 세대 구조(Eden·Survivor·Old), TLAB 할당, 객체 승격 흐름, 약한 세대 가설, Metaspace와 비힙 영역의 수명 규칙을 다룹니다.
java.util.Date와 Calendar에 숨어 있는 0-base 월, 가변성, SimpleDateFormat 스레드 불안전, getYear() 오프셋 같은 함정을 정리하고, 레거시 코드를 java.time으로 점진 마이그레이션하는 전략을 다룹니다.
이번 달 마지막 날, 다음 금요일 같은 상대 날짜 계산을 담당하는 TemporalAdjuster의 동작 원리, 내장 adjuster 카탈로그, 람다 기반 커스텀 adjuster(다음 영업일 등) 작성법을 정리합니다.
DateTimeFormatter의 내장 포맷터와 ofPattern 사용법, 패턴 문자 치트시트, 로케일 처리, YYYY·hh 같은 단골 패턴 버그, SimpleDateFormat 대비 스레드 안전성까지 정리합니다.
에포크 기반 타임스탬프 Instant의 구조와 활용, 시간량을 표현하는 Duration과 Period의 차이, DST 경계에서 '하루'의 두 가지 의미, 실행 시간 측정 패턴까지 정리합니다.
ZonedDateTime의 구조(LocalDateTime + ZoneOffset + ZoneId)와 생성·변환 API, DST 경계의 Gap·Overlap 처리, OffsetDateTime과의 차이, 타임존 간 변환 패턴을 정리합니다.
LocalDateTime의 생성과 분해, 연산 API를 정리하고, 타임존이 없는 LocalDateTime이 타임라인 위의 한 점이 아니라는 핵심 개념과 실무에서 써도 되는 경우·안 되는 경우를 구분합니다.
java.time의 가장 기본 타입인 LocalDate와 LocalTime의 생성, 조회, 연산, 비교 메서드를 실무 예제와 함께 정리하고, 불변 객체 연산에서 주의할 점을 살펴봅니다.
java.util.Date와 Calendar의 고질적인 문제점부터 Java 8 java.time(JSR-310)의 설계 원칙, 핵심 클래스 구성과 선택 기준까지 모던 날짜·시간 API의 전체 그림을 정리합니다.
Java 8·11·17·21 LTS 버전의 출시 히스토리, 각 버전 간 주요 브레이킹 체인지, 실무 마이그레이션 체크리스트, 버전 선택 가이드를 종합 정리합니다.
Java 21 LTS의 Virtual Threads 표준화, Pattern Matching Switch, Record Patterns, Sequenced Collections, Scoped Values Preview, String Templates Preview를 상세히 정리합니다.
Java 18의 UTF-8 기본 인코딩·Simple Web Server, Java 19·20의 Virtual Threads Preview, Structured Concurrency, Record Patterns, Scoped Values 등 Java 21 LTS의 준비 단계를 정리합니다.
Java 17 LTS의 Sealed Classes 표준화, Pattern Matching Switch Preview, Strong Encapsulation, RandomGenerator API, macOS AArch64 지원, 보안 강화와 제거된 항목을 정리합니다.
Java 12부터 16까지 Preview로 도입되어 표준화된 Switch 표현식(14), Text Block(15), Records(16), Pattern Matching for instanceof(16), Sealed Classes Preview 등 핵심 언어 기능을 총정리합니다.
Java 11 LTS의 핵심 변화인 HTTP Client API 표준화, String 신규 메서드, Lambda에서 var 사용, Files 유틸리티 추가, ZGC 도입, Java EE 모듈 제거를 코드 예제와 함께 정리합니다.
Java 9의 모듈 시스템(JPMS), JShell, Collection Factory Methods, Stream/Optional 개선과 Java 10의 var 키워드, G1GC 기본 변경, 6개월 릴리스 사이클 시작을 정리합니다.
Java 8에서 도입된 Lambda, Stream API, Optional, Date/Time API, Functional Interface, Method Reference, CompletableFuture 등 핵심 기능을 예제 중심으로 총정리합니다.
Java Virtual Thread를 프로덕션 환경에서 안전하게 활용하기 위한 DO/DON'T 패턴, 기존 코드 마이그레이션 전략, Spring Boot·Tomcat 등 프레임워크 통합 방법을 정리합니다.
Virtual Thread가 Carrier 스레드에 고정(Pinned)되는 조건, JFR로 Pinning을 탐지하는 방법, ReentrantLock 교체 및 Java 23 JEP 491 업그레이드 전략을 상세히 정리합니다.
Java 21에서 도입된 Structured Concurrency(JEP 453)의 핵심 원칙, StructuredTaskScope의 ShutdownOnFailure와 ShutdownOnSuccess 정책, 취소 전파, 그리고 기존 비동기 패턴과의 비교를 정리합니다.
Thread.ofVirtual(), startVirtualThread(), newVirtualThreadPerTaskExecutor(), ThreadFactory 네 가지 생성 방법, 생명주기 상태 전이, 이름 지정, 취소 처리, 그리고 모니터링 방법을 정리합니다.
플랫폼 스레드와 Virtual Thread의 OS 매핑 방식, 메모리 모델, 스케줄링 차이, Pinning 문제, ThreadLocal vs ScopedValue, 그리고 각각의 적합한 사용 시나리오를 정리합니다.
Java 21에서 정식 출시된 Virtual Threads(JEP 444)의 동작 원리, mount/unmount 메커니즘, I/O 블로킹 처리 방식, 그리고 기존 플랫폼 스레드 모델과의 핵심 차이를 정리합니다.
exceptionally, handle, whenComplete의 동작 차이, CompletionException 언래핑, 타임아웃 처리, 그리고 비동기 파이프라인에서 예외를 안전하게 다루는 패턴을 실전 예제로 정리합니다.
thenCombine, allOf, anyOf, applyToEither 등 CompletableFuture 조합 연산자의 동작 원리와 사용 패턴, 그리고 allOf 결과 수집 관용구를 실전 예제로 정리합니다.
Java 8에서 도입된 CompletableFuture의 생성 방법, 상태 전이, 콜백 체이닝(thenApply/thenCompose/thenAccept), 동기 vs 비동기 변형, 그리고 get()과 join()의 차이를 실전 예제로 정리합니다.
Fork/Join 프레임워크의 두 핵심 클래스 RecursiveTask와 RecursiveAction의 차이, compute() 구현 패턴, invokeAll() 활용, 그리고 흔한 실수를 실전 예제와 함께 정리합니다.
Java 7에서 도입된 Fork/Join 프레임워크의 분할 정복 패턴, Work-Stealing 알고리즘, ForkJoinPool 설정, 그리고 병렬 스트림과의 관계를 실전 예제와 함께 정리합니다.
ExecutorCompletionService를 활용해 여러 비동기 작업의 결과를 제출 순서가 아닌 완료 순서로 수집하는 방법과, Future.get() 블로킹 문제를 해소하는 실전 패턴을 정리합니다.
java.util.concurrent.Callable 인터페이스를 Runnable과 비교하고, checked 예외 전파 방식, ExecutorService와의 통합, 람다 표현식으로 간결하게 작성하는 방법, 그리고 자주 사용하는 패턴을 예제와 함께 정리합니다.
java.util.concurrent.Future의 상태 기계(PENDING/DONE/CANCELLED/FAILED), get()·cancel()·isDone() 메서드, FutureTask 내부 구조, 예외 처리 패턴, CompletableFuture로의 전환 시점을 설명합니다.
Executors 클래스의 팩토리 메서드 5종(Fixed/Cached/Single/Scheduled/VirtualThread)의 내부 구현, 장단점, 실운영 함정을 비교하고 각 메서드 선택 기준을 명확히 정리합니다.
ThreadPoolExecutor의 작업 수락 흐름(코어 → 큐 → 최대 스레드 → 거부), 다섯 가지 파라미터 의미, 큐 유형 선택, 스레드 풀 크기 결정 공식(CPU/IO 집약), 모니터링 방법을 상세히 설명합니다.
java.util.concurrent Executor 프레임워크의 인터페이스 계층(Executor → ExecutorService → ThreadPoolExecutor), ExecutorService 생명주기, submit/invoke 차이, 올바른 종료 패턴을 설명합니다.
Java 21에서 finalized된 ScopedValue API를 소개합니다. ThreadLocal과 비교해 불변성·자동 해제·가상 스레드 친화성에서 어떻게 다른지, where/run 패턴과 중첩 바인딩, StructuredTaskScope와의 통합을 예제로 설명합니다.
ThreadLocal의 내부 구조(ThreadLocalMap), 초기값 설정, 사용자 컨텍스트·DB 커넥션 전파 패턴, 스레드 풀에서 메모리 누수를 피하는 remove() 습관, 가상 스레드와의 주의사항을 정리합니다.
Java 메모리 모델의 핵심 happens-before 관계를 6가지 규칙으로 정리하고, 이행성 체인을 통해 멀티스레드 코드의 안전성을 추론하는 방법을 예제와 함께 설명합니다.
JMM이 정의하는 가시성·원자성·순서 재배치 세 가지 문제와 volatile·synchronized·happens-before 규칙으로 멀티스레드 코드를 안전하게 작성하는 방법을 설명합니다.
Java 멀티스레드에서 발생하는 라이브락(Livelock)과 기아 현상(Starvation)의 원인, 증상, 랜덤 백오프·공정 락으로 해결하는 실전 전략을 정리합니다.
Java 교착 상태 4가지 발생 조건, 고전적 패턴(락 순서 역전), 락 획득 순서 고정·tryLock 타임아웃으로 예방, jstack/ThreadMXBean으로 감지, 라이브락·기아 현상 구분
java.util.concurrent의 스레드 안전 컬렉션 완전 가이드 — ConcurrentHashMap, CopyOnWriteArrayList, BlockingQueue 계열, Collections.synchronizedXxx 함정
java.util.concurrent.locks.Condition 인터페이스, await/signal/signalAll, 생산자-소비자 BoundedBuffer 구현, wait/notifyAll과의 비교, 스퍼리어스 웨이크업 처리
Java StampedLock의 3가지 모드(Write/Read/Optimistic Read), 스탬프 기반 락 관리, 낙관적 읽기 패턴, ReentrantReadWriteLock과 성능 비교, 재진입 불가 주의사항
java.util.concurrent.locks.Lock 인터페이스, ReentrantLock 공정성, tryLock 타임아웃, lockInterruptibly, ReadWriteLock, Condition 변수, synchronized와의 선택 기준
java.util.concurrent.atomic 패키지의 AtomicInteger, AtomicReference, LongAdder 등 CAS 기반 Lock-Free 동기화, ABA 문제와 해결책, LongAdder vs AtomicLong 성능 비교
Java volatile 키워드의 CPU 캐시 가시성 문제 해결, happens-before 보장, 명령어 재정렬 방지, synchronized와의 차이, 이중 검사 잠금(DCL) 패턴
Java synchronized 키워드의 모니터 락 동작 원리, 메서드/블록 형태, 재진입성, wait/notify, JVM Lock 최적화(Biased→Thin→Fat), 성능 고려 사항
Java Thread 우선순위(MIN/NORM/MAX_PRIORITY), OS 스케줄러와의 관계, 데몬 스레드 개념과 JVM 종료 메커니즘, ThreadFactory 패턴, 가상 스레드의 데몬 특성
Java Thread.State 열거형의 6가지 상태(NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED)와 각 상태 전이 조건, getState() 활용, interrupt 처리 패턴
Java Runnable 인터페이스와 Thread 클래스 완전 가이드 — 스레드 생성 3가지 패턴, start vs run, sleep/join/interrupt, 데몬 스레드, Thread.ofVirtual()
Java Thread 기초 완전 가이드 — 프로세스 vs 스레드, JVM 메모리 구조, Thread.State 6가지, 스레드가 필요한 이유, 플랫폼 스레드 vs 가상 스레드
Java Record 직렬화 완전 가이드 — 생성자 기반 역직렬화 보장, writeObject 제한, Jackson/Gson과 Record 통합, @JsonProperty 활용, 불변식 보호
Java 직렬화의 4가지 함정 완전 분석 — 역직렬화 공격(CVE), 성능 문제, 하위 호환성 부담, JEP 290 필터, Jackson/Protobuf/Kryo 대안 비교
Java Serialization 완전 가이드 — Serializable 인터페이스, ObjectOutputStream/InputStream, serialVersionUID, transient, writeObject/readObject 커스터마이징, readResolve
Java AsynchronousFileChannel 완전 가이드 — CompletionHandler 콜백, Future 기반 읽기/쓰기, 병렬 오프셋 접근, AsynchronousChannelGroup, CompletableFuture 연계
Java WatchService 완전 가이드 — 파일 생성/수정/삭제 이벤트 감지, WatchKey 상태 관리, key.reset() 필수 패턴, 재귀 감시 구현
Java NIO Selector 완전 가이드 — 논블로킹 채널 등록, SelectionKey 이벤트(OP_ACCEPT/READ/WRITE), 에코 서버 구현, Selector vs 스레드 풀 비교
Java NIO의 Channel과 ByteBuffer 완전 가이드 — FileChannel, ByteBuffer 상태(flip/clear/compact), Heap vs Direct 버퍼, transferTo 제로 카피
Java Path 인터페이스와 Paths 팩토리 완전 정복 — Path.of(), resolve, relativize, normalize, getParent/getFileName, Path↔File↔URI 상호 변환
Java Files 클래스 완전 가이드 — readString/writeString, readAllBytes, copy/move/delete, createDirectories, walk/list 디렉터리 탐색, Path vs File 비교, StandardOpenOption 활용
Java BufferedReader Writer 완전 분석 — 버퍼링 동작 원리와 성능 차이, readLine() EOF null 처리, lines() Stream API, BufferedWriter newLine(), PrintWriter autoFlush, 인코딩 지정 방법
Java 바이트 스트림과 문자 스트림 심화 — InputStream read() int 반환의 이유, EOF -1 처리, read(buf) 부분 읽기 문제, OutputStream flush() 필수, Reader/Writer 문자 인코딩, BufferedReader.lines() Stream 활용
Java IO 완전 개요 — InputStream/OutputStream vs Reader/Writer, 바이트 스트림과 문자 스트림 차이, 데코레이터 패턴, InputStreamReader 브리지, java.io vs java.nio vs java.nio.file 비교
Java 예외 처리 베스트 프랙티스 — 예외 삼키기 금지, 로그 중복 방지, 흐름 제어에 예외 사용 금지, Checked vs Unchecked 선택 기준, 경계 계층에서만 처리, 예외 메시지 작성법
Java RuntimeException 종류 완전 정리 — NullPointerException Helpful NPE, IllegalArgumentException, IllegalStateException, IndexOutOfBoundsException, ClassCastException, ConcurrentModificationException 발생 원인과 방어 패턴
Java 예외 체이닝 완전 분석 — cause 전달의 중요성, initCause() vs 생성자, getCause() 체인 탐색, 계층형 아키텍처에서의 예외 래핑 패턴, 근본 원인 추적
Java 커스텀 예외 설계 완전 가이드 — RuntimeException vs Exception 선택 기준, ErrorCode enum 패턴, 도메인 루트 예외 계층 구조, 생성자 4종 구현, 직렬화 serialVersionUID
Java multi-catch 완전 분석 — catch (A | B e) 구문, implicitly final 변수, LUB 타입 추론, catch 블록 순서와 예외 계층 주의사항, multi-catch 활용 패턴
Java try-with-resources 완전 분석 — AutoCloseable 구현 방법, Suppressed Exception 처리, 다중 자원 역순 close, Java 9 effectively final 변수 지원, 구식 finally 패턴과 비교
Java try-catch-finally 완전 분석 — try·catch·finally 실행 순서, 다중 catch와 예외 순서, finally 항상 실행 보장, finally에서 return 금지, try-with-resources로 자원 자동 해제, suppressed exception, AutoCloseable 구현 방법
Java Checked vs Unchecked 예외 완전 비교 — 컴파일러 강제 처리 차이, 복구 가능성 기준으로 선택하는 방법, Checked를 Unchecked로 래핑하는 패턴, Spring이 Unchecked를 선호하는 이유, 람다에서 Checked 예외 처리 문제
Java 예외 처리 완전 정리 — Throwable·Error·Exception 계층 구조, Checked vs Unchecked 예외 차이, 예외 전파 메커니즘, throw와 throws 사용법, 예외 처리 설계 원칙, 예외를 언제 던지고 언제 처리해야 하는지 판단 기준
Java Optional 안티패턴 7가지 완전 분석 — isPresent+get 패턴, 파라미터·필드에 Optional, Optional 컬렉션, 중첩 Optional, orElse에 비용 큰 식, Optional.get() 직접 사용, Before/After 교정 코드, IntelliJ 경고 활용
Java Optional 모범 사례 완전 정리 — 메서드 반환 타입으로만 사용, isPresent+get 안티패턴 대신 orElse 계열 사용, 파라미터와 필드로 사용하지 않는 이유, Spring Service 레이어 패턴, Optional 체이닝 실전 코드, orElse vs orElseGet 성능 선택
Java Optional 메서드 완전 정리 — map·flatMap·filter 변환 파이프라인, get·orElse·orElseGet·orElseThrow 값 추출 차이, ifPresent·ifPresentOrElse 소비 메서드, or·stream Java9 추가 메서드, orElse vs orElseGet 성능 차이
Java Optional 생성 완전 분석 — Optional.of와 ofNullable 차이, Optional.empty 싱글턴, null 전달 시 즉시 NPE 발생하는 이유, OptionalInt·OptionalLong·OptionalDouble 기본 타입 전용 Optional, JPA·Stream·Map과의 연동 패턴
Java Optional 완전 정리 — Optional이 해결하는 NullPointerException 문제, Optional.of·empty·ofNullable 생성, map·flatMap·filter 파이프라인, orElse·orElseGet·orElseThrow 값 추출, Optional 설계 의도와 올바른 사용 범위
Java 불변 객체 완전 정리 — 불변 클래스 설계 5가지 규칙, final 클래스·필드·setter 금지, 방어적 복사, 불변 컬렉션 활용, String·BigDecimal·LocalDate 등 JDK 불변 클래스, 멀티스레드 안전성과 성능 트레이드오프
Java 커링 완전 분석 — 커링 개념과 부분 적용 차이, Function 체인으로 구현하는 커링 패턴, BiFunction 커링, 로거·검증·설정 팩토리 등 실전 활용, 커링이 적합한 상황과 오남용 주의점
Java 함수 합성 완전 분석 — Function.andThen()과 compose()의 실행 순서 차이, Predicate.and()·or()·negate() 조합, Consumer.andThen() 체이닝, UnaryOperator 파이프라인, 함수 합성으로 재사용 가능한 변환 파이프라인 설계하는 실전 패턴
java.util.function Bi 계열 함수형 인터페이스 완전 분석 — BiFunction<T,U,R>의 apply와 andThen, BiPredicate<T,U>의 test·and·or·negate, BiConsumer<T,U>와 Map.forEach, BinaryOperator와 Stream.reduce, ToIntBiFunction 등 기본형 특화
java.util.function 패키지의 43개 내장 함수형 인터페이스 완전 정리 — Function·Consumer·Supplier·Predicate의 추상 메서드·기본 메서드·조합 패턴, UnaryOperator·BinaryOperator, 기본형 특화 IntFunction·ToIntFunction·IntConsumer 등, 언제 커스텀 함수형 인터페이스를 만들어야 하는지
Java 메서드 참조(Method Reference) 4가지 유형 완전 분석 — 정적 메서드 참조, 특정 객체 인스턴스 메서드 참조, 임의 객체 인스턴스 메서드 참조, 생성자 참조의 문법·동작·람다 대응 관계, 언제 메서드 참조가 더 나은지 판단 기준
Java 람다 표현식 완전 정리 — 기본 문법(파라미터·화살표·본문), 익명 클래스와의 비교, 타겟 타입 추론, effectively final 캡처, this 참조 차이, invokedynamic 구현 원리, 람다를 쓰면 좋은 상황과 나쁜 상황
Java Stream API와 전통적인 for/while 루프의 성능·가독성·디버깅·병렬화·조기 탈출 측면 비교 — JMH 벤치마크 결과, 상황별 선택 가이드, Stream이 더 나은 경우와 루프가 더 나은 경우, 팀 코드 컨벤션 설정 방법
Java Stream 실무에서 자주 만나는 함정 — 스트림 재사용 IllegalStateException, forEach 사이드 이펙트, 무한 스트림 limit 누락, 지연 실행 오해, 병렬 스트림 공유 상태, Optional.get() 무검증, checked exception 처리, 과도한 체이닝
Java 병렬 스트림의 내부 구조 — ForkJoinPool.commonPool 동작 원리, 병렬화 효과가 큰 조건과 역효과 조건, 커스텀 ForkJoinPool로 격리 실행, 공유 상태·순서 의존 연산의 위험성, JMH 벤치마크로 성능 검증
Stream.flatMap()의 동작 원리와 map()과의 차이점 — 중첩 컬렉션 평탄화, 문자열 분리, Optional 연쇄, flatMapToInt/Long/Double 기본형 특화, Stream.empty()로 null 대체하는 실전 패턴
Collectors.groupingBy의 다운스트림 Collector 파라미터 완전 분석 — counting·summingInt·mapping·joining·collectingAndThen·teeing 조합 패턴, 다중 레벨(2단계·3단계) 중첩 그루핑, 집계 결과를 불변 맵으로 변환하는 실전 패턴
java.util.stream.Collectors 전체 — toList·toSet·toMap·joining·groupingBy·partitioningBy·counting·summingInt·minBy·maxBy·mapping·collectingAndThen·teeing(Java 12)까지, 다운스트림 Collector 조합 패턴과 중복 키 처리
Stream 종료 연산 전체 — collect(Collectors.*)·toList(), reduce의 identity/Optional 형태 차이, count·min·max·sum·average·summaryStatistics, findFirst·findAny와 Optional 반환, anyMatch·allMatch·noneMatch 단락 평가, forEach·forEachOrdered·toArray
Stream 중간 연산 전체 정리 — Stateless(filter·map·flatMap·peek·mapToInt)와 Stateful(sorted·distinct·limit·skip·takeWhile·dropWhile) 분류, flatMap의 평탄화 원리, Java 9 takeWhile/dropWhile, Java 16 mapMulti, 병렬 스트림에서의 주의사항
Stream 생성의 모든 방법 — collection.stream()·Arrays.stream()·Stream.of()·ofNullable()·empty(), 무한 스트림 iterate와 generate, Java 9의 iterate 종료 조건, Files.lines·Pattern.splitAsStream·String.chars, Stream.Builder와 concat까지
Java 8 Stream API의 소스·중간 연산·종료 연산으로 이루어진 파이프라인 구조, 지연 평가(lazy evaluation)와 단락 평가(short-circuit), Stateless vs Stateful 중간 연산 차이, IntStream·LongStream·DoubleStream 기본 타입 특화 스트림
컬렉션 선택 기준(ArrayList vs LinkedList vs HashMap vs TreeMap), 초기 용량 지정으로 재할당 방지, 인터페이스 타입 선언 원칙, ConcurrentModificationException 회피, null 처리, equals/hashCode 계약, 빈 컬렉션 반환 관행까지
Java 9에서 도입된 List.of·Map.of·Set.of 불변 팩토리의 null 불허·중복 불허 특성, Java 10 copyOf로 독립 복사본 생성, Stream.toList(Java 16)와 toUnmodifiableList 차이, Map.ofEntries로 10쌍 한도 우회까지
java.util.Arrays의 sort·parallelSort·binarySearch·copyOf·copyOfRange·fill·equals·deepEquals·toString·stream·asList 전체 메서드 정리와 기본 타입 Dual-Pivot QuickSort vs 객체 TimSort 차이, asList 고정 크기 함정까지
java.util.Collections가 제공하는 sort·binarySearch·shuffle·min·max 등 정렬 검색 메서드, unmodifiable·synchronized·checked 래퍼 팩토리, nCopies·singletonList·disjoint 등 편의 메서드와 현대적 대안 정리
PriorityQueue의 이진 최소 힙 내부 구조, offer/poll/peek API 차이, Comparator로 역순·커스텀 정렬, Top-K 문제와 다익스트라 등 실전 패턴, 그리고 스레드 안전 대안 PriorityBlockingQueue까지
Queue와 Deque 인터페이스 계층, offer/poll/peek의 null 반환 vs add/remove/element의 예외 방식, ArrayDeque를 Queue·Stack으로 사용하는 패턴, PriorityQueue·BlockingQueue 등 주요 구현체 비교
ConcurrentHashMap의 Java 7 세그먼트 락과 Java 8 버킷 단위 CAS/synchronized 구조, null 불허 이유, putIfAbsent/computeIfAbsent/merge 원자 연산, Hashtable 대비 성능 비교, 그리고 올바른 동시성 패턴
TreeMap의 Red-Black Tree 기반 구조, NavigableMap 메서드(floorKey/ceilingKey/subMap/headMap/tailMap), Comparator를 통한 커스텀 정렬, null 키 불허 이유, 그리고 TreeMap이 빛나는 실전 사용 사례
LinkedHashMap의 삽입 순서·접근 순서 두 가지 모드, removeEldestEntry를 활용한 LRU 캐시 구현, HashMap 대비 성능·메모리 트레이드오프, 그리고 실전 활용 패턴
HashMap 버킷 배열·Entry 체이닝·트리 전환 구조, Java 8 보조 해시 함수, getOrDefault/computeIfAbsent/merge 등 Java 8+ API, load factor와 capacity 최적화, 그리고 thread-safe 대안
TreeSet의 Red-Black Tree 기반 구조, O(log n) 성능, NavigableSet 메서드(floor/ceiling/headSet/tailSet/subSet), Comparable과 Comparator를 통한 커스텀 정렬, 그리고 TreeSet이 적합한 상황
LinkedHashSet의 LinkedHashMap 기반 구조, 해시 버킷과 이중 연결 리스트의 결합, HashSet 대비 메모리·성능 트레이드오프, 그리고 삽입 순서 보존이 필요한 실전 사용 사례
HashSet 내부 HashMap 기반 구조, 해시 버킷과 충돌 처리(연결 리스트→트리), equals/hashCode 계약, load factor와 capacity 튜닝, 그리고 HashSet을 올바르게 사용하기 위한 실전 패턴
Vector와 Stack의 역사·내부 구조·synchronized 문제, Stack이 List를 상속하는 설계 결함, 그리고 현대 Java에서 ArrayDeque와 Collections.synchronizedList로 대체하는 실전 마이그레이션 가이드
LinkedList 내부 이중 연결 리스트 노드 구조, ArrayList와의 성능 트레이드오프, Deque 인터페이스 구현체로서의 활용, 그리고 LinkedList를 실제로 선택해야 할 상황과 피해야 할 상황
List 인터페이스의 핵심 메서드, ArrayList 내부 동적 배열 구조와 1.5배 확장 원리, 성능 특성(O(1) get vs O(n) insert), initialCapacity 최적화, ArrayList와 LinkedList 선택 기준
Iterable→Collection→List/Set/Queue 계층, Map의 별도 계층, 주요 구현체 선택 기준 표, Iterable·Collection 공통 인터페이스 메서드, 그리고 어떤 컬렉션을 언제 써야 하는지 가이드
Raw type 사용, 힙 오염 위험, instanceof 검사 불가, 제네릭 배열 생성 불가, T 인스턴스화 불가, 오버로딩 충돌, 브리지 메서드 이해, @SuppressWarnings unchecked 올바른 사용법
타입 소거(Type Erasure)가 하위 호환성을 위해 T를 Object로 치환하는 과정, 소거 후 캐스팅 코드 자동 삽입, 런타임에 제네릭 타입 정보가 없는 이유, 힙 오염(Heap Pollution), 그리고 reifiable 타입
PECS(Producer Extends Consumer Super) 원칙의 의미와 암기법, Collections.copy 시그니처 분석, 생산자와 소비자 역할 구분, 그리고 API 설계에서 와일드카드를 올바르게 쓰는 방법
비한정 와일드카드 <?>, 상한 와일드카드 <? extends T>, 하한 와일드카드 <? super T>의 읽기·쓰기 제약, 제네릭 불공변 문제 해결, 그리고 sumList·addNumbers 실전 예제
상한 경계 <T extends Number>, 다중 경계 <T extends A & B>, 경계 지정 시 T의 메서드 호출 가능성, 재귀 타입 경계 <T extends Comparable<T>>, 그리고 min·sum 구현 실전 예제
제네릭 메서드 선언 위치(반환 타입 앞 <T>), 타입 추론, 비 제네릭 클래스의 static 제네릭 메서드, swap·identity 예제, 그리고 명시적 타입 인자 호출법
제네릭 클래스 선언 문법, 단일·다중 타입 파라미터, 제네릭 인터페이스, 상속 관계에서의 타입 인자 전달, 그리고 Pair<K,V>와 Stack<E> 예제로 배우는 실전 설계
제네릭이 해결하는 타입 안전성 문제, 타입 파라미터 이름 관례(T·E·K·V·N·R), 다이아몬드 연산자, 그리고 Box<T> 예제로 이해하는 제네릭의 핵심 개념
불변 객체의 5가지 설계 규칙(final 클래스, final 필드, setter 금지, 방어적 복사), 스레드 안전성과 HashMap 키 안전성, wither 패턴으로 변경된 복사본 반환, 그리고 record를 활용한 간결한 불변 클래스 구현 방법
java.lang.Comparable과 java.util.Comparator의 차이, compareTo() 반환값 규칙, Comparator.comparing()과 thenComparing()으로 다중 기준 정렬 체이닝, Collections.sort와 TreeMap에서의 활용법을 실전 코드로 정리한다
Object.finalize()가 Java 9에서 deprecated되고 Java 18에서 forRemoval로 강화된 이유, finalize()의 4가지 근본적 문제점, 그리고 AutoCloseable+try-with-resources와 java.lang.ref.Cleaner를 활용한 올바른 자원 관리 방법
Object.clone()의 동작 원리와 Cloneable 마커 인터페이스, 얕은 복사와 깊은 복사의 차이, clone()을 올바르게 구현하는 방법, 그리고 복사 생성자와 정적 팩터리 메서드를 대안으로 활용하는 방법을 실전 코드로 정리한다
Object.toString()의 기본 출력 형식과 한계, 오버라이드해야 하는 이유, toString()이 자동 호출되는 상황, 올바른 구현 패턴과 formatted() 활용, 그리고 순환 참조·민감 정보 포함 같은 주의사항을 실전 코드로 정리한다
Object.equals()와 hashCode()의 5가지 계약(반사성·대칭성·추이성·일관성·null 비교), equals 오버라이드 시 hashCode를 반드시 쌍으로 구현해야 하는 이유, HashMap에서 계약 위반 시 발생하는 버그, 그리고 Objects.hash()를 활용한 올바른 구현 패턴
java.lang.Object가 모든 클래스의 최상위 부모인 이유, Object가 제공하는 11가지 메서드의 목적과 기본 동작, equals·hashCode·toString·clone·wait·notify의 올바른 사용법과 오버라이드 가이드를 실전 코드로 정리한다
Java 21에서 정식 출시된 record 패턴의 문법, instanceof와 switch에서 record 컴포넌트를 즉시 분해 바인딩하는 방법, 중첩 record 패턴, var 타입 추론, when 가드 절을 실전 코드로 정리한다
Java 16에서 정식 출시된 record 클래스의 문법과 자동 생성 멤버, 컴팩트 생성자로 유효성 검사 추가하는 방법, 인터페이스 구현과 커스텀 메서드 추가, 그리고 record의 제약사항과 활용 패턴을 실전 코드로 정리한다
Java 17에서 정식 도입된 sealed 클래스와 인터페이스의 문법, permits 키워드로 허용 구현체를 지정하는 방법, final·sealed·non-sealed 세 가지 하위 타입 제약, 그리고 패턴 매칭 switch와의 조합으로 얻는 완전성 검사를 실전 코드로 정리한다
Java가 클래스 다중 상속을 허용하지 않는 이유, 인터페이스로 다중 상속을 구현하는 방법, Java 8 default 메서드가 일으키는 다이아몬드 충돌, 그리고 세 가지 해결 규칙과 InterfaceName.super 문법을 실전 코드로 정리한다
메서드 없이 빈 몸체만 존재하는 마커 인터페이스의 동작 원리, JDK 내장 예시(Serializable, Cloneable, RandomAccess), 커스텀 마커 인터페이스 작성, 그리고 어노테이션과의 트레이드오프를 실전 코드와 함께 정리한다
함수형 인터페이스의 정의, SAM 규칙, @FunctionalInterface 어노테이션, java.util.function 주요 인터페이스, 합성 메서드(andThen/compose/and/or), 커스텀 함수형 인터페이스 설계를 실전 예제와 함께 정리한다
Java 9에서 도입된 인터페이스 private 메서드의 규칙, private vs private static 차이, default/static 메서드의 공통 로직 분리, 실전 설계 패턴을 상세히 정리한다
Java 8 인터페이스 static 메서드의 도입 배경, 상속 불가 규칙, 팩토리 메서드 패턴, 유틸리티 클래스 대체, JDK 활용 사례, Java 9 private static까지 실전 설계 관점에서 정리한다
Java 8에서 도입된 default 메서드의 도입 배경, 동작 원리, 재정의 규칙, 충돌 해결, 템플릿 메서드·동작 합성 패턴, 실전 안티패턴까지 깊이 파헤친다
Java 인터페이스의 계약 정의, abstract/default/static/private 메서드, 다중 구현, 인터페이스 상속, default 메서드 충돌 해결, 함수형 인터페이스까지 예제 중심으로 완전 정복한다
Java 추상 클래스의 abstract 키워드, 추상 메서드, 구체 메서드, 생성자 활용, final 조합, 템플릿 메서드 패턴까지 예제 중심으로 완전 정복한다
Java 다형성의 핵심인 업캐스팅, 동적 디스패치, 다운캐스팅, instanceof 패턴 매칭을 예제 중심으로 완전 정복하고 OCP 원칙과의 연결까지 설명한다
Java super 키워드의 3가지 사용법(생성자 호출, 메서드 호출, 필드 접근)을 예제 중심으로 완전 정복하고, 생성자 체이닝 흐름과 컴파일러 자동 삽입 규칙까지 설명한다
Java 메서드 오버라이딩의 5가지 규칙, @Override 애노테이션의 역할, 동적 디스패치 원리, super 메서드 호출 패턴, 오버로딩과의 차이점을 예제 중심으로 완전 정복한다
Java 상속(inheritance)의 동작 원리와 extends 키워드 사용법, protected 접근 제어자, super() 생성자 체인, IS-A 관계 설계 원칙까지 예제 중심으로 완전 정복한다
getter와 setter의 올바른 작성법과 흔한 안티패턴을 분석하고, setter 없는 불변 객체·빌더 패턴·record를 활용해 캡슐화를 더 강하게 유지하는 설계 기법을 완전 정복한다
캡슐화(Encapsulation)의 핵심 원리인 정보 은닉과 불변식 보호를 이해하고, private 필드·공개 메서드 패턴으로 객체가 항상 유효한 상태를 유지하도록 설계하는 방법을 완전 정복한다
Java 네 가지 접근 제어자의 적용 범위와 차이를 정확히 이해하고, 클래스·필드·메서드·생성자에 올바르게 적용하는 캡슐화 설계 원칙을 완전 정복한다
Java final 키워드가 변수, 메서드, 클래스 각각에서 어떤 의미를 갖는지, JVM 최적화와 불변 객체 설계까지 final의 모든 것을 완전 정복한다
Java static 키워드가 메모리와 JVM에서 어떻게 동작하는지, static 필드·메서드·초기화 블록의 생명 주기와 실전 패턴(상수, 팩토리, 싱글톤)을 완전 정복한다
Java 메서드 오버로딩의 원리부터 컴파일러 오버로드 해소 3단계, varargs 우선순위, 오토박싱·제네릭과의 상호작용까지 실전 예제로 완전 정복한다
Java this 키워드의 세 가지 용법을 완전 정복한다. 필드/매개변수 구별, 현재 객체 참조 반환(메서드 체이닝), this()를 통한 생성자 위임까지 원리부터 활용 패턴까지 설명한다
Java 생성자의 모든 것을 파헤친다. 기본 생성자, 매개변수 생성자, 생성자 오버로딩, this() 체이닝의 원리와 설계 원칙을 예제 중심으로 완전 정복한다
Java 클래스를 구성하는 핵심 요소인 필드와 메서드를 완전 정복한다. 타입별 기본값, 인스턴스 vs 정적 멤버, 값 전달 방식(pass by value), return 문까지 상세히 다룬다
Java 객체지향의 핵심인 클래스와 객체 개념을 코드와 메모리 구조로 완전히 이해한다. 클래스 선언, new 키워드, 참조 변수, 힙·스택 메모리까지 한 번에 정복
Java 15에서 정식 도입된 Text Block의 문법, 들여쓰기 자동 제거 원리, 이스케이프 시퀀스, formatted() 활용까지 여러 줄 문자열을 완전 정복한다
String 연결이 느린 이유, StringBuilder와 StringBuffer의 내부 구조·차이, 핵심 API 사용법, 성능 최적화 전략까지 가변 문자열을 완전 정복한다
Java String Pool의 위치 변화(PermGen → Heap), 리터럴과 new String()의 차이, intern() 동작 원리, StringTable 튜닝까지 메모리 관점에서 완전 정복한다
Java String의 불변성 원리, charAt부터 strip까지 핵심 메서드, == vs equals 함정, String.format 활용까지 실전 중심으로 정리한다
Java 2차원 배열의 힙 구조, 가변 배열(Jagged Array), 행렬 전치·회전, Arrays.deepToString, 캐시 효율까지 다차원 배열의 모든 것을 실전 코드와 함께 정리한다
Java 배열의 선언·생성·초기화·접근·순회부터 Arrays 유틸리티 클래스까지, 힙 메모리 구조와 흔한 함정을 포함해 배열의 모든 것을 정리한다
Java 21에 정식 도입된 패턴 매칭 switch의 타입 패턴, Guarded Pattern(when 절), null 처리, sealed class 완전성 검사, 그리고 레코드 패턴까지 실전 예제 중심으로 완전히 정리한다
Java 14에 정식 도입된 switch 표현식의 화살표 레이블, yield 키워드, 다중 레이블, 완전성 검사까지 전통 switch 문과 비교하며 코드 예제 중심으로 완전히 정리한다
if·else, for, while, do-while, for-each, break, continue, return, labeled break까지 Java의 모든 제어 흐름 구조를 예제 중심으로 완전히 정리하고, 가드 클로즈·무한 루프 탈출 등 실무 패턴까지 해설한다
Java의 산술·비교·논리·비트·대입·삼항 연산자 전체를 우선순위와 함께 정리하고, 단락 평가·정수 오버플로·패턴 매칭 instanceof 등 실무에서 자주 마주치는 함정까지 예제 중심으로 완전히 해설한다
Java 자동 형 확장 변환과 명시적 캐스팅, 기본형·참조형 변환, 오버플로·정밀도 손실 함정, 업캐스팅·다운캐스팅, instanceof 패턴 매칭까지 예제 중심으로 완전히 정리한다
Java 참조형의 개념, 힙·스택 메모리 구조, null 처리, 동일성 vs 동등성, 그리고 클래스·인터페이스·배열·열거형 4가지 종류를 예제 중심으로 완전히 정리한다
Java 8가지 기본형의 크기·범위·기본값과 자동 형 변환, 래퍼 클래스, 주의사항을 예제 중심으로 완전히 정리한다
Java 변수 선언 구조, 네 가지 변수 종류, 여섯 가지 리터럴 형태를 코드와 함께 깊이 있게 정리한다
Java 개발 환경을 확인하고 Hello World 프로그램을 작성·컴파일·실행하는 전체 흐름을 한 줄씩 상세히 익힌다
.class 파일의 내부 구조와 각 섹션의 역할을 상수 풀부터 메서드 테이블까지 상세히 알아본다
JVM 바이트코드 명령어를 6대 분류별로 정리합니다. 로드·스토어, 산술·논리, 타입 변환, 제어 흐름, 메서드 호출·반환, 객체·배열 명령어의 동작 원리를 javap 출력과 함께 실전 코드로 분석합니다.
Java 소스가 .class 파일로 컴파일되는 과정, javap로 바이트코드를 직접 읽는 방법, 오퍼랜드 스택과 로컬 변수 테이블의 동작 원리를 단계별로 설명합니다.
JVM의 Tiered Compilation 5단계 레벨 전환 전략을 심층 분석합니다. C1·C2 컴파일러가 큐 상태와 프로파일 성숙도에 따라 협력하는 방식, PrintCompilation 로그 해석, 서버리스·고처리량·벤치마크 환경별 최적 설정을 다룹니다.
JVM의 Just-In-Time 컴파일 메커니즘을 심층 분석합니다. C1·C2 컴파일러의 역할 분담, 메서드 인라이닝·탈출 분석·루프 최적화 등 핵심 기법, Code Cache 관리, Deoptimization 시나리오까지 다룹니다.
JVM 실행 엔진의 구성 요소인 Interpreter, C1/C2 JIT Compiler, Garbage Collector의 역할과 협력 방식, 티어드 컴파일 흐름, Deoptimization 개념까지 정리합니다.
Eden·Survivor·Old Generation·Metaspace 세대 구조, TLAB 할당 원리, Minor/Major/Full GC 발생 조건, 그리고 운영 환경에서 Heap을 튜닝하는 핵심 JVM 옵션을 정리합니다.
Heap·Metaspace·Code Cache·JVM Stack·PC Register·Native Method Stack 등 JVM이 실행 중에 사용하는 메모리 영역별 구조와 역할, OOM·SOE 발생 조건, 진단 방법까지 정리합니다.
부모 위임 모델의 내부 동작, 위임이 깨지는 SPI 딜레마와 컨텍스트 클래스 로더로 해결하는 방법, Java 9 모듈 시스템과의 관계, OSGi·Tomcat이 위임을 재정의하는 이유까지 깊이 파헤칩니다.
Bootstrap · Platform · Application 세 계층의 클래스 로더, 부모 위임 모델의 동작 원리, 로딩·링킹·초기화 3단계 프로세스, 그리고 커스텀 클래스 로더 구현까지 깊이 있게 살펴봅니다.
클래스 로더 서브시스템, 런타임 데이터 영역, 실행 엔진까지 JVM 내부 구조를 시각적으로 이해하고 Java 프로그램이 실행되는 원리를 낱낱이 파헤칩니다.
Java 9에서 도입된 JShell REPL 환경의 기본 사용법, 슬래시 명령, 자동완성, 스크립트 실행, 학습과 프로토타이핑에 활용하는 실전 팁을 정리합니다.
Javadoc 주석 작성 규칙, @param·@return·@throws 등 핵심 블록 태그, javadoc 명령 실행 방법, Gradle·Maven 연동까지 실전 중심으로 정리합니다.
Java의 클래스패스(-cp)와 Java 9에서 도입된 모듈패스(-p)의 차이점, module-info.java 작성 방법, 레거시 라이브러리와의 혼합 사용 전략을 실용적으로 설명합니다.
javac, java, jar, javap, jps, jstat, jstack, jcmd 등 JDK bin/ 디렉터리에 포함된 핵심 도구들의 용도와 실전 사용법을 범주별로 정리합니다.
SDKMAN을 이용해 Eclipse Temurin, Amazon Corretto, GraalVM 등 다양한 JDK 배포판을 설치·전환하는 방법을 단계별로 설명하고, .sdkmanrc로 프로젝트별 버전을 고정하는 실무 워크플로를 소개합니다.
Java 개발 환경을 구성하는 세 축인 JDK, JRE, JVM의 역할과 포함 관계를 명확히 이해하고, 각 구성 요소가 소스 코드 실행에서 어떤 역할을 담당하는지 정리합니다.
Eclipse Temurin, Amazon Corretto, Oracle JDK, Microsoft OpenJDK 등 주요 JDK 배포판의 특징·라이선스·지원 기간을 비교하고 프로젝트에 맞는 선택 기준을 제시합니다.
WORA 슬로건의 기술적 배경과 JVM이 플랫폼 독립성을 실현하는 원리, 바이트코드의 역할, 그리고 실무에서 마주치는 한계까지 정리합니다.
Java 9부터 도입된 6개월 릴리즈 사이클과 LTS(장기 지원) 버전의 의미, 지원 기간, 벤더별 배포판 선택 기준을 정리합니다.
Java SE, Java ME, Jakarta EE(구 Java EE)의 차이와 역할을 이해하고, 실무에서 어떤 에디션이 어떤 맥락에서 쓰이는지 정리합니다.
Oak 언어 탄생부터 Java 21 LTS까지, Java 30년 역사의 주요 이정표와 각 버전이 남긴 유산을 살펴봅니다.
Java의 정의, 핵심 철학 'Write Once, Run Anywhere', JVM 기반 실행 원리, 그리고 왜 지금도 Java를 배워야 하는지 알아봅니다.