TiLog

[KB IT's Your Life 7기] 14주차 교육 후기: JDBC

tissue_0321 — Mon, 8 Jun 2026 20:31:50 +0900

앞서 DB 파트에서 DBMS 개요와 데이터베이스 모델링을 다뤘다면,

이번 주차부터는 드디어 Java와 DB를 연결하는 단계로 넘어왔습니다

프론트엔드, DB를 다 배우고 나서 이 둘을 이어주는 파트가 나온다는 게

커리큘럼 구성 자체가 꽤 잘 짜여있다는 생각이 들었습니다

이번 주차에서 다룬 내용은 하나입니다

-------- JDBC 프로그래밍 --------

1. JDBC란?

1. JDBC 개념

JDBC는 Java Database Connectivity의 약자로,

Java에서 데이터베이스와 연결해서 입출력을 지원하는 기술입니다

핵심은 DBMS의 종류와 상관없이 동일하게 사용할 수 있는

클래스와 인터페이스로 구성되어 있다는 점입니다

Oracle을 쓰든, MySQL을 쓰든, MariaDB를 쓰든

애플리케이션 코드는 동일한 JDBC 인터페이스를 사용하고,

각 DBMS에 맞는 JDBC Driver가 중간에서 실제 통신을 담당합니다

그래서 DB를 바꿔도 애플리케이션 코드를 크게 수정할 필요가 없다는 장점이 있습니다

이 구조가 바로 앞서 배웠던 DBMS 독립성과 연결되는 부분입니다

2. JDBC 개발 절차

JDBC로 DB와 통신하는 절차는 크게 6단계로 나뉩니다

1단계는 JDBC 드라이버 로드입니다

Class.forName()을 사용해서 드라이버 클래스를 메모리에 올립니다

드라이버가 없으면 ClassNotFoundException이 발생합니다

2단계는 데이터베이스 연결입니다

DriverManager.getConnection()으로 Connection 객체를 생성합니다

연결 문자열 형식은 jdbc:mysql://[host]:[포트]/[db이름] 입니다

3단계는 Statement 생성, 4단계는 SQL문 전송, 5단계는 결과 받기, 6단계는 연결 해제입니다

SELECT문 실행에는 executeQuery()를 사용해서 ResultSet을 반환받고,

INSERT, UPDATE, DELETE에는 executeUpdate()를 사용해서 영향받은 행 수를 반환받습니다

2. 환경 설정

1. 데이터베이스 및 사용자 준비

먼저 MySQL에서 실습용 데이터베이스와 사용자를 준비합니다

CREATE DATABASE jdbc_ex;

CREATE USER 'scoula'@'%' IDENTIFIED BY '1234';
GRANT ALL PRIVILEGES ON jdbc_ex.* TO 'scoula'@'%';
FLUSH PRIVILEGES;

GRANT로 권한을 부여하고 FLUSH PRIVILEGES로 적용하는 과정입니다

2. Gradle 프로젝트 설정

IntelliJ에서 Gradle 프로젝트를 생성한 뒤,

build.gradle에 MySQL Connector와 Lombok 의존성을 추가합니다

implementation 'com.mysql:mysql-connector-j:8.3.0'
compileOnly 'org.projectlombok:lombok:1.18.30'
annotationProcessor 'org.projectlombok:lombok:1.18.30'

수정 후에는 반드시 Sync를 실행해줘야 합니다

그리고 Lombok을 사용하려면 IntelliJ 설정에서 Annotation Processing도 활성화해야 합니다

이전에 IntelliJ Gradle JDK 설정 오류를 다뤘던 경험이 있어서

이번에는 Gradle 8.x에 맞게 JDK 17로 미리 맞춰놓고 진행했습니다

3. IntelliJ Datasource 설정

IntelliJ에는 DB 연결을 직접 관리할 수 있는 Datasource 기능이 있습니다

Database 탭에서 MySQL을 선택하고

Host, Port, User, Password, Database를 입력하면

IDE 내에서 바로 쿼리를 작성하고 실행할 수 있습니다

Test Connection으로 연결을 확인하면 Succeeded와 함께

MySQL 버전, 드라이버 정보, Ping 응답 시간이 표시됩니다

3. 핵심 클래스와 실습

1. JDBCUtil 모듈화

DB 연결과 해제는 어디서든 반복적으로 필요한 코드입니다

그래서 이걸 common 패키지의 JDBCUtil 클래스로 모듈화합니다

application.properties 파일에 연결 정보를 분리해두고

JDBCUtil의 static 블록에서 Properties를 읽어 Connection을 생성합니다

getConnection()으로 연결을 가져오고, close()로 해제합니다

이렇게 하면 나중에 DB 정보가 바뀌어도

코드 대신 properties 파일만 수정하면 됩니다

2. Statement vs PreparedStatement

SQL을 실행하는 방법에는 Statement와 PreparedStatement 두 가지가 있습니다

Statement는 SQL 문자열을 그대로 실행합니다

값을 변수로 대체하려면 문자열 연결 연산자로 직접 이어붙여야 하는데,

이 방식은 SQL Injection에 취약하고 코드 가독성도 떨어집니다

PreparedStatement는 SQL에 ?로 파라미터를 표시하고

setString(), setInt() 등으로 값을 안전하게 바인딩합니다

보안과 가독성 측면에서 PreparedStatement를 사용하는 것이 훨씬 낫습니다

3. ResultSet

SELECT 쿼리의 결과는 ResultSet으로 받습니다

커서는 최초에 beforeFirst 위치에 있고, next()를 호출할 때마다 한 행씩 이동합니다

더 이상 행이 없으면 next()가 false를 반환합니다

각 컬럼의 값은 getString("컬럼명"), getInt("컬럼명") 등으로 추출합니다

4. VO 패턴과 DAO 패턴

1. VO 패턴

VO는 Value Object의 약자로, 특정 테이블의 한 행을 매핑하는 클래스입니다

클래스 정의가 테이블, 필드들이 컬럼들, 인스턴스가 한 행에 해당합니다

UserVO 클래스에는 id, password, name, role 필드가 있고,

Lombok의 @Data, @NoArgsConstructor, @AllArgsConstructor 어노테이션으로

getter, setter, 생성자를 자동으로 생성합니다

2. DAO 패턴

DAO는 Data Access Object의 약자로,

데이터베이스에 접근하여 실질적인 연동 작업을 담당하는 클래스입니다

테이블에 대한 CRUD 연산을 처리하며, 인터페이스를 먼저 정의한 후 구현 클래스를 작성합니다

UserDao 인터페이스에는 create, getList, get, update, delete 메서드가 정의되어 있고,

UserDaoImpl에서 각 메서드를 PreparedStatement로 구현합니다

ResultSet을 UserVO로 변환하는 map() 메서드를 별도로 만들어두면

여러 조회 메서드에서 재사용할 수 있어서 코드가 훨씬 깔끔해집니다

마지막으로 IntelliJ의 Generate Test 기능을 활용하면

UserDao 인터페이스 기준으로 테스트 클래스를 자동으로 생성할 수 있습니다

각 메서드에 @Order 어노테이션으로 실행 순서를 지정하면

insert → select → update → delete 순서대로 테스트가 진행됩니다

이번 주차는 개인적으로 가장 체감이 컸던 주차였습니다

React로 프론트엔드를 개발할 때 DB 연동은 항상 백엔드가 처리해줬는데

JDBC를 통해 Java 코드가 직접 DB와 통신하는 전체 흐름을 처음으로 밑바닥부터 구현해봤습니다

특히 VO와 DAO 패턴으로 코드를 분리하는 구조가

나중에 배울 MyBatis나 JPA 같은 ORM의 기반이 될 것 같아서

확실히 이해하고 넘어가야겠다는 생각이 들었습니다

Statement보다 PreparedStatement를 써야 하는 이유,

ResultSet 커서가 처음에 beforeFirst에 위치하는 구조 같은 부분들이

직접 코드를 짜봐야 머릿속에 남는 것들이라서

이번 주 실습이 꽤 유익했습니다

다음 주차도 기대하면서, 수료까지 파이팅!!!!

[KB IT's Your Life 7기] 13주차 후기 - MYSQL과 DBMS

tissue_0321 — Mon, 1 Jun 2026 09:37:33 +0900

안녕하세요!

알고리즘 특강까지 다 끝나고, 이제 DBMS로 들어갑니다!

디비 커리큘럼이 생각보다 길어서 놀랐지만 ~

JDBMS까지 상세하게 배우는 것 같아서 좋네요!!

이거 다 끝나면 Spring배우고 프로젝트..

벌써 3개월이나 지났다는게 넘 신기하네요 :)

배운 내용 정리해보겠습니다!

1. DBMS 개요

1. 데이터베이스란?

데이터베이스를 한 마디로 정의하자면

'데이터의 집합' 입니다

여러 명의 사용자나 응용프로그램이 공유하고,

동시에 접근 가능해야 하는 데이터의 저장 공간 자체를 의미합니다

그리고 DBMS는 이 데이터베이스를 관리하고 운영하는 역할을 합니다

MySQL, Oracle, SQL Server 같은 것들이 전부 여기에 해당하죠

2. DB/DBMS의 특징

DBMS를 쓰는 이유가 뭘까요?

그냥 엑셀에 저장하면 안 되나? 라고 생각할 수도 있는데

DBMS에는 엑셀에는 없는 핵심 특징들이 있습니다

첫 번째는 데이터의 무결성(Integrity)입니다

데이터베이스 안의 데이터는 오류가 없어야 하고,

이를 위해 제약 조건(Constraint)이라는 특성을 가집니다

두 번째는 데이터의 독립성입니다

데이터베이스 크기를 변경하거나 저장소를 바꿔도

기존에 작성된 응용프로그램은 전혀 영향을 받지 않아야 합니다

세 번째는 보안입니다

데이터를 소유한 사람이나 접근이 허가된 사람만 접근할 수 있어야 하고,

사용자의 계정에 따라서 다른 권한을 가집니다

이 외에도 데이터 중복의 최소화, 응용프로그램 제작 및 수정이 쉬워짐,

데이터의 안전성 향상 등의 특징이 있습니다

3. DBMS 분류

DBMS는 시대에 따라 발전해온 역사가 있습니다

가장 먼저 나온 건 계층형 DBMS로, 1960년대에 시작됐습니다

각 계층은 트리(Tree) 형태의 1:N 관계로 구성되는데,

처음 구축한 이후 구조를 변경하기가 상당히 까다롭고

접근 유연성이 부족해서 임의의 검색에는 어려움이 있었습니다

이 문제를 개선하기 위해 1970년대에 망형 DBMS가 등장했습니다

1:1, 1:N, N:M(다대다) 관계를 지원해서 효과적이고 빠른 데이터 추출이 가능해졌지만,

복잡한 내부 포인터 때문에 프로그래머가 모든 구조를 이해해야만

프로그램 작성이 가능하다는 단점이 있었습니다

그리고 현재 가장 많이 사용되는 관계형 DBMS(Relational DBMS)가 있습니다

1969년 E.F.Codd라는 학자가 수학 모델에 근거해 고안했고,

데이터베이스를 테이블(Table)이라 불리는 최소 단위로 구성합니다

관계형 DBMS의 장점은

업무가 변화될 경우 쉽게 적응 가능하고,

대용량 데이터 관리와 데이터 무결성 보장이 된다는 점입니다

단점으로는 시스템 자원을 많이 차지해서

전반적으로 느려지는 문제가 있었는데,

하드웨어가 발전하면서 현재는 사실상 해결된 상태입니다

4. SQL 개요

관계형 DBMS에서 사용되는 언어가 바로 SQL입니다

'에스큐엘' 또는 '시퀄'이라고 읽습니다

SQL의 특징은

DBMS 제작 회사와 독립적이고, 다른 시스템으로 이식성이 좋다는 점입니다

Oracle에서는 PL/SQL, SQL Server에서는 T-SQL처럼

각 회사마다 표준 SQL을 기반으로 한 자체 언어가 있지만

핵심 문법은 동일하게 적용됩니다

2. 데이터베이스 모델링

1. 데이터베이스 모델링이란?

데이터베이스 모델링은

현실 세계에서 사용되는 작업이나 사물들을 DBMS의 데이터베이스 개체로 옮기기 위한 과정입니다

쇼핑몰을 예로 들면,

현실에서는 고객이 물건을 사는 행위가 있죠

이걸 데이터베이스로 표현하면

고객 테이블, 직원 테이블, 구매 테이블, 물품 테이블 이런 식으로 변환되는 겁니다

모델링의 단계는 크게 세 가지로 나뉩니다

개념적 모델링은 업무 분석 단계에 포함되고,

논리적 모델링은 업무 분석의 후반부와 시스템 설계의 전반부에 걸쳐 진행되며,

물리적 모델링은 시스템 설계의 후반부에 주로 진행됩니다

2. 쇼핑몰 데이터 예제로 이해하기

처음에는 고객 방문 기록과 구매 내역이 하나의 테이블에 섞여 있습니다

여기서 물건을 구매하지 않은 고객은 구매 관련 컬럼이 전부 비어있는 L자형 테이블이 됩니다

이렇게 되면 낭비되는 공간이 엄청 생기죠

그래서 빈칸이 있는 곳과 없는 곳을 분류해

고객 테이블(userTBL)과 구매 테이블(buyTBL)로 나눕니다

이렇게 하면 공간도 절약되고, 관리도 훨씬 쉬워집니다

이 과정에서 핵심 개념이 등장합니다

기본 키(PK, Primary Key)는

각 행을 구분하는 유일한 값으로, 중복되지 않고 비어있지 않아야 합니다

고객 테이블에서는 고객 이름이 PK 역할을 합니다

외래 키(FK, Foreign Key)는

외래 키로 부모 테이블에서 유일하게 하나의 정보를 얻을 수 있습니다

구매 테이블의 고객 이름 컬럼이 고객 테이블의 PK를 참조하는 FK가 되는 거죠

테이블 간의 관계에서는 주(Master)가 되는 쪽이 부모 테이블이 됩니다

고객이 물건을 소유하는 거지, 물건이 고객을 소유하는 건 아니니까

고객 테이블이 부모, 구매 테이블이 자식이 되는 1:N 모델입니다

제약 조건도 중요합니다

새로운 데이터가 들어갈 때는 부모 테이블에 먼저 넣어야 하고,

데이터 삭제 시에는 자식 테이블에서도 함께 지워야 합니다

3. Workbench로 다이어그램 만들기

이론으로만 배운 내용을 MySQL Workbench를 활용해서

실제로 ER 다이어그램으로 시각화하는 실습도 진행했습니다

모델 다이어그램을 작성한 뒤 Forward Engineer 기능을 이용하면

다이어그램이 자동으로 SQL문으로 변환되어 실제 데이터베이스에 적용됩니다

반대로 이미 존재하는 데이터베이스를 Reverse Engineer로 불러와서

다이어그램으로 변환하는 것도 가능합니다

테이블을 분리하고 PK/FK로 관계를 맺는 과정이

처음에는 당연한 것처럼 써왔는데,

이번에 왜 이렇게 설계하는지 그 배경을 제대로 이해하게 됐습니다

L자형 테이블에서 시작해서 정규화된 형태로 변환하는 과정이

굉장히 직관적으로 설명되어 있어서 이해하기 좋았습니다

앞으로 SQL 문법이나 실제 쿼리 작성 파트가 기대됩니다

아무튼, 이번 주도 무사히 수료!!!!

[KB IT's Your Life 7기] 12주차 후기 - 코딩테스트 준비

tissue_0321 — Tue, 26 May 2026 12:57:25 +0900

[KB IT's Your Life 7기] 12주차 후기 - 코딩테스트 준비

안녕하세요! KB IT's Your Life 7기 기자단입니다

벌써 12주차가 됐네요! 시간이 정말 빠르게 지나가는 것 같아요.

이번 주는 본격적인 알고리즘 준비 에 들어갔어요.

재귀, 그리디, 완전 탐색 개념을 배우고, 지난 시간에 배웠던 DFS까지 활용해서 문제도 직접 풀어봤답니다!

오늘 포스팅에서 차근차근 정리해볼게요

1. 재귀 (Recursion)

재귀란 함수가 자기 자신을 다시 호출하는 것 이에요.

처음 들으면 좀 신기하게 느껴지죠? 함수가 자기 자신을 부른다고?!

재귀를 사용하면 복잡한 문제를 작은 단위로 쪼개서 해결할 수 있어요.

대표적인 예시로 팩토리얼 계산이 있어요.

int factorial(int n) {
    if (n == 1) return 1;       // 기저 조건 (Base Case)
    return n * factorial(n - 1); // 재귀 호출
}

여기서 핵심 포인트가 하나 있어요!

재귀 함수를 만들 때는 반드시 기저 조건(Base Case) 을 설정해야 해요.

기저 조건이 없으면 함수가 무한히 자기 자신을 호출하다가 스택 오버플로우가 발생하거든요

재귀 호출이 일어날 때마다 문제의 크기가 점점 작아지고, 기저 조건에 도달하면 호출이 멈추면서 결과가 쌓여서 올라오는 구조예요!

2. 그리디 (Greedy)

그리디는 매 순간 가장 좋아 보이는 선택을 하는 알고리즘 이에요.

이름 그대로 탐욕적으로, 지금 당장 눈앞에 있는 최선의 선택을 계속해서 쌓아가는 방식이죠!

대표적인 예시로 거스름돈 문제가 있어요.

1260원을 거슬러줘야 할 때, 500원 → 100원 → 50원 → 10원 순서로 큰 단위부터 최대한 많이 사용하는 거예요.

int change = 1260;
int coins[] = {500, 100, 50, 10};
int count = 0;

for (int i = 0; i < 4; i++) {
    count += change / coins[i];
    change %= coins[i];
}

cout << count << endl; // 6

그런데 그리디가 항상 정답을 보장하진 않아요!

그리디 알고리즘이 통하려면 탐욕적 선택이 최적해를 보장하는 문제 여야 해요.

문제를 보고 "매 순간의 최선이 전체의 최선이 될 수 있는가?" 를 먼저 판단하는 게 중요해요.

3. 완전 탐색 (Brute Force)

완전 탐색은 말 그대로 가능한 모든 경우의 수를 다 탐색해서 답을 찾는 방법 이에요.

무식해 보이지만, 사실 가장 확실한 방법이기도 해요

완전 탐색의 대표적인 방식으로는 이런 것들이 있어요.

반복문(Loop) → 단순히 모든 경우를 반복문으로 순회하는 방법
재귀(Recursion) → 모든 경우를 재귀적으로 탐색하는 방법
BFS / DFS → 그래프나 트리 구조에서 모든 노드를 탐색하는 방법
순열 / 조합 → 모든 순열이나 조합을 생성해서 탐색하는 방법

완전 탐색은 시간 복잡도가 높아질 수 있기 때문에, 입력 크기가 작을 때 유효해요.

문제를 보고 "입력 범위가 작다!" 싶으면 완전 탐색을 먼저 떠올려보는 게 좋아요!

4. 잠깐! 지난 시간 복습 - BFS와 DFS

지난 시간에 BFS(너비 우선 탐색) 와 DFS(깊이 우선 탐색) 를 공부했는데요!

주로 BFS 위주로 다뤘었죠.

오늘은 재귀까지 배웠으니 DFS를 제대로 활용해볼 차례예요!

간단하게 두 개를 비교하고 넘어갈게요.

BFS DFS

탐색 방식	가까운 노드부터 탐색	깊이 우선으로 탐색
자료구조	큐(Queue)	스택(Stack) 또는 재귀
최단 경로	✅ 유리	❌ 불리
메모리	상대적으로 많이 사용	상대적으로 적게 사용
적합한 문제	최단 경로, 레벨 탐색	경우의 수, 백트래킹

DFS는 재귀와 찰떡궁합이에요!

깊이 들어가면서 모든 경우를 탐색하고, 막히면 되돌아오는 백트래킹 방식으로 활용할 수 있거든요.

그럼 바로 실전 문제로 가볼게요!

5. 예시 문제 풀어보기 - 프로그래머스 : 양과 늑대

오늘 배운 재귀 + DFS를 활용해서 풀 수 있는 문제를 가져왔어요!

바로 프로그래머스의 "양과 늑대" 문제예요.

문제 설명

이진 트리 구조의 노드들이 주어지고, 각 노드에는 양(0) 또는 늑대(1)가 있어요.

루트 노드(0번)부터 시작해서 트리를 탐색하는데, 방문한 노드의 양과 늑대 수를 누적해요.

단, 늑대 수 ≥ 양 수 가 되는 순간 양이 모두 잡아먹혀서 탐색이 불가능해져요.

이 조건을 지키면서 탐색할 때, 최대로 모을 수 있는 양의 수 를 구하는 문제예요!

풀이 핵심 아이디어

핵심은 이거예요.

특정 노드를 방문하면, 그 노드의 자식 노드들이 새롭게 방문 가능한 후보 로 추가돼요.

그리고 후보 중 어떤 노드를 다음에 방문할지는 자유롭게 선택할 수 있어요.

즉, 현재 방문 가능한 후보 노드 목록을 들고 다니면서 DFS로 모든 경우를 탐색하면 돼요!

️ C++ 풀이 코드

#include <bits/stdc++.h>
using namespace std;

int answer = 0;
vector<int> graph[18];

void dfs(int node, vector<int> next, int sheep, int wolf, int* info) {
    // 현재 노드가 양인지 늑대인지 확인
    if (info[node] == 0) sheep++;
    else wolf++;

    // 늑대 수가 양 수 이상이면 탐색 중단
    if (wolf >= sheep) return;

    // 최댓값 갱신
    answer = max(answer, sheep);

    // 현재 노드의 자식들을 후보에 추가
    vector<int> nextNodes = next;
    for (int child : graph[node]) {
        nextNodes.push_back(child);
    }

    // 현재 노드는 후보에서 제거 후 나머지 후보 탐색
    nextNodes.erase(find(nextNodes.begin(), nextNodes.end(), node));

    // 후보 노드들 중 하나씩 선택해서 DFS
    for (int next_node : nextNodes) {
        dfs(next_node, nextNodes, sheep, wolf, info);
    }
}

int solution(vector<int> info, vector<vector<int>> edges) {
    // 트리 구성
    for (auto& edge : edges) {
        graph[edge[0]].push_back(edge[1]);
    }

    // 루트(0번)에서 시작, 초기 후보는 {0}
    dfs(0, {0}, 0, 0, info.data());

    return answer;
}

코드 흐름 정리

Step 1. 트리를 인접 리스트로 구성해요.

Step 2. 루트 노드(0번)부터 DFS를 시작해요. 초기 후보 목록은 {0} 이에요.

Step 3. 현재 노드 방문 시 양/늑대 수를 업데이트하고, 늑대 ≥ 양이면 즉시 리턴해요.

Step 4. 현재 노드의 자식들을 후보 목록에 추가하고, 현재 노드는 후보에서 제거해요.

Step 5. 남은 후보 노드들을 하나씩 선택해서 재귀적으로 탐색해요.

Step 6. 탐색하면서 양의 수 최댓값을 계속 갱신해요.

6. 이번 주 느낀 점 ✍️

이번 주는 정말 알고리즘의 핵심들을 한꺼번에 배운 느낌이에요.

재귀는 처음엔 머릿속에서 계속 호출이 쌓이는 게 잘 안 그려져서 어려웠는데, 직접 코드를 짜보면서 점점 감이 잡히더라고요!

그리디는 "이게 진짜 최선인가?" 를 항상 의심하면서 접근해야 한다는 게 포인트인 것 같아요.

완전 탐색은 확실한 만큼 시간 복잡도를 항상 염두에 두는 습관이 중요하다는 걸 느꼈어요.

그리고 오늘 풀어본 양과 늑대 문제는 DFS + 백트래킹의 묘미를 제대로 느낄 수 있는 문제였어요!

후보 노드를 들고 다니면서 탐색하는 아이디어가 처음엔 낯설었지만, 이해하고 나니까 정말 깔끔한 풀이라는 생각이 들었답니다

앞으로도 꾸준히 알고리즘 문제를 풀면서 실력을 키워나가야겠어요!

다음 포스팅에서도 유익한 내용으로 돌아올게요

[KB IT's Your Life 7기] 11주차 후기, 코딩 테스트 자료 구조

tissue_0321 — Mon, 18 May 2026 10:52:02 +0900

[11주차 후기, 코딩 테스트 자료 구조]

안녕하세요!

이번 주차는 알고리즘 특강이 진행되었습니다.

5월에는 유독 특강이 많은 것 같네요!

AI 수업도 들었고, 알고리즘 수업은 무려 8일 동안 진행되었습니다.

특강으로 보기엔 길지만, 알고리즘을 완벽하게 공부하기에는 짧은 시간.. ㅎㅎ

기본적으로 비전공자도 공통 강의를 수강하기 때문에,

수업은 전체적으로 기초부터 쌓을 수 있도록 상세하게 진행되었습니다.

특별 강사님은 개발남노씨가 오셨습니다!!!!

잘 모르시는 분이었는데, 강의를 엄청 잘해주셔서 놀랐습니다.

심지어 전공은 전전이라고 하시더라구요...

대단하신 분인 것 같습니다.

수강생을 위한 노션 페이지도 준비해주셨습니다.

코딩테스트 시험 환경은 어떻고, 난이도는 어느 정도로 나오는지

그리고 빈출 알고리즘은 어떤게 있는지!

잘 모르는 분들에게 많은 도움이 될 것 같았습니다.

수업은 오전에 공통 강의로 알고리즘 또는 자료구조를 알려주시고,

오후 시간에는 반별 코치님들의 관리 하에 문제 풀이를 진행했습니다.

다들 아시다시피.. 백준이 섭종을 해서 그런지!!!

문제들을 전부 프로그래머스로 준비해주셨더라구요.

저는 미리 여러 번 풀어봤던 문제라, 빠르게 풀이할 수 있었습니다.

그런데 문제 풀 때 프로그래머스 환경이 따라주지 않아서 힘들었던... ㅎㅎㅎ

"올바른 괄호" 문제 풀이 중 분명 시간 복잡도까지 고려한 코드인데,

계속해서 시간 초과가 떠서 한 10번 정도 다시 채점을 시도했습니다.

역시 코드는 정답인데 서버 환경 때문에 계속 오답이 나오던 거더라구요...

자료 구조로는 가장 기본적인 스택과 큐에 대한 설명이 있었습니다.

전공자이지만 수업 내용을 열심히 들었는데,

비전공자도 이해하기 쉽게 설명을 잘 해주셨습니다!

Stack은 선입선출

Queue는 후입선출

적절한 상황에 자료구조를 잘 사용하는 것이 중요한 것 같습니다!

Q&A 시간에는 공통적인 질문이 많이 들어왔었습니다.

바로... 코테 언어로 무엇을 선택해야 하냐는 질문인데요!

요즘 다양한 언어를 지원해주기도 하지만,

보수적인 기업들은 python도 지원해주지 않는 곳도 있어서 다들 질문을 많이 하시는 것 같았습니다.

저도 사실 c++로 풀이를 하고 있는데..

프론트엔드를 공부하면서, javascript로 코테 준비를 하지 않은 것을..

사실 천만 다행으로 생각하고 있습니다.

그랬다면 지금쯤 다시 c++로 준비했을 것 같습니다.

아무튼, 결론적으로 python c++ java 셋 중 하나를 해라!

라고 추천해주셨는데요

python도 그래도 "웬만하면" 지원해주기 때문에,

초보자 입장에서는 Pythond으로 코테 공부를 하는게 좋은 것 같습니다.

[문제 풀이]

[PS] 전화번호 목록

문제 프로그래머스SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프programmers.co.kr 어떤 전화번호가 다른 전화번호의 접두사가 되는 경우가 있는지 확인한다

ts0321.tistory.com

예전에 제가 풀이하면서 올렸던 글인데,

이번 알고리즘 특강 2일차를 수강하면서 다시 풀게 되어 생각이 났습니다.

도움이 되시길 바라며, 다음 포스팅으로 돌아오겠습니다!

[KB IT's Your Life] 10주차 후기, 람다

tissue_0321 — Mon, 11 May 2026 10:06:22 +0900

[10주차 수강 후기]

람다식 완전 정복하기

안녕하세요! KB IT's Your Life 7기 기자단입니다

오늘은 자바에서 코드를 훨씬 간결하고 우아하게 만들어주는

람다식(Lambda Expression) 에 대해 정리해볼게요.

처음엔 화살표(->) 기호가 낯설게 느껴질 수 있지만,

차근차근 따라오시면 분명히 이해되실 거예요!

람다식이란?
먼저 기본 개념부터 짚고 갈게요.
람다식은 함수형 프로그래밍에서 나온 개념이에요.
함수형 프로그래밍이란, 함수를 정의하고 그 함수를 데이터 처리부로 보내서 데이터를 처리하는 기법인데요.
여기서 람다식은 바로 그 데이터 처리부에 제공되는 함수 역할을 하는 매개변수를 가진 중괄호 블록이에요.
자바는 이 람다식을 익명 구현 객체로 변환해서 처리한답니다!

람다식의 기본 문법은 이렇게 생겼어요.
(매개변수, …) -> { 처리 내용 }
화살표(->) 를 기준으로 왼쪽엔 매개변수, 오른쪽엔 처리할 내용이 들어가는 구조예요.
정말 심플하죠?

함수형 인터페이스 (Functional Interface)
람다식을 사용하려면 함수형 인터페이스가 필요해요.
함수형 인터페이스란, 추상 메소드가 단 하나뿐인 인터페이스를 말해요.
그리고 그 인터페이스에 @FunctionalInterface 어노테이션을 붙여주면, 컴파일러가 추상 메소드가 하나인지 자동으로 검사해줘서 실수를 방지할 수 있어요!

기존에 익명 구현 객체를 만들던 방식보다 훨씬 간결하죠?!

java@FunctionalInterface
public interface Calculable {
    // 추상 메소드
    void calculate(int x, int y);
}

그리고 이 인터페이스를 람다식으로 사용하면 이렇게 돼요.
javaaction((x, y) -> {
    int result = x + y;
    System.out.println("result: " + result);
});

매개변수가 없는 람다식

함수형 인터페이스의 추상 메소드에 매개변수가 없을 경우엔 이렇게 써요.

() -> { 실행문; 실행문; }

그런데 실행문이 딱 하나라면 중괄호를 생략할 수 있어요!

() -> 실행문

실제 코드로 보면 이런 느낌이에요.

// 실행문이 두 개 이상일 경우 중괄호 필요
person.action(() -> {
System.out.println("출근을 합니다.");
System.out.println("프로그래밍을 합니다.");
});

// 실행문이 한 개일 경우 중괄호 생략 가능
person.action(() -> System.out.println("퇴근합니다."));

중괄호 생략 가능 여부가 헷갈릴 수 있으니 꼭 기억해두세요!

매개변수가 있는 람다식
이번엔 매개변수가 있는 람다식이에요.
매개변수를 선언할 때 타입은 생략 가능하고, 구체적인 타입 대신 var를 사용할 수도 있어요.

(타입 매개변수, …) -> { 실행문; }
(var 매개변수, …) -> { 실행문; }
(매개변수, …) -> { 실행문; }

그리고 매개변수가 딱 하나일 경우엔 괄호까지 생략할 수 있어요!
단, 이때는 타입이나 var를 붙일 수 없다는 점 주의하세요

java// 매개변수가 두 개일 경우
person.action1((name, job) -> {
    System.out.print(name + "이 ");
    System.out.println(job + "을 합니다.");
});

// 매개변수가 한 개일 경우 괄호 생략 가능
person.action2(word -> System.out.println(""" + word + ""라고 외칩니다."));

리턴값이 있는 람다식
함수형 인터페이스의 추상 메소드에 리턴값이 있을 경우엔 return 문을 사용해요.
그런데 return 문이 딱 하나라면 중괄호와 return 키워드를 모두 생략할 수 있어요!
연산식이나 리턴값이 있는 메소드 호출로 바로 대체할 수 있거든요.

// 일반적인 방식
person.action((x, y) -> {
    double result = x + y;
    return result;
});

// return 하나일 경우 생략 가능 (연산식)
person.action((x, y) -> (x + y));

// return 하나일 경우 생략 가능 (메소드 호출)
person.action((x, y) -> sum(x, y));

세 가지 방식 모두 결과는 동일하게 14.0이 출력돼요.
코드 스타일에 맞게 선택해서 쓰면 된답니다

메소드 참조 (Method Reference)
람다식을 더 줄일 수 있는 방법도 있어요.
바로 메소드 참조예요!
람다식이 단순히 어떤 메소드를 호출하는 역할만 한다면, :: 기호를 사용해서 더 간결하게 표현할 수 있어요.

람다식
person.action((x, y) -> Computer.staticMethod(x, y));

메소드 참조 (정적 메소드)
person.action(Computer::staticMethod);

람다식
person.action((x, y) -> com.instanceMethod(x, y));

메소드 참조 (인스턴스 메소드)
person.action(com::instanceMethod);

정리하면 이렇게 돼요!

생성자 참조 (Constructor Reference)
마지막으로 생성자 참조예요!
람다식이 단순히 객체를 생성하고 리턴하는 역할만 한다면, 생성자 참조로 대체할 수 있어요.

java// 람다식
(a, b) -> { return new 클래스(a, b); }

// 생성자 참조
클래스::new

실제 코드에선 이렇게 써요.

javaMember m1 = person.getMember1(Member::new);
Member m2 = person.getMember2(Member::new);

같은 Member::new 표현이지만,

함수형 인터페이스의 추상 메소드 매개변수 개수에 따라

컴파일러가 자동으로 맞는 생성자를 찾아서 실행해준답니다.

생성자가 없으면 컴파일 오류가 발생하니 주의하세요!

오늘은 람다식의 핵심 개념들을 정리해봤어요!

람다식 = 데이터 처리부에 제공되는 함수 역할의 중괄호 블록

함수형 인터페이스 = 추상 메소드가 단 하나인 인터페이스, @FunctionalInterface로 보장

매개변수 없는 람다식 = () -> { ... }, 실행문 하나면 중괄호 생략 가능

매개변수 있는 람다식 = 타입 생략 가능, 매개변수 하나면 괄호도 생략 가능

리턴값 있는 람다식 = return 하나면 중괄호·return 모두 생략 가능

메소드 참조 = 클래스::메소드 또는 참조변수::메소드

생성자 참조 = 클래스::new

처음엔 -> 기호가 어색하게 느껴질 수 있지만,

직접 코드를 써보면서 연습하다 보면 금방 익숙해질 거예요!

다음 포스팅에서도 유익한 내용으로 돌아올게요

[알고리즘] 격자판 슬라이딩 탐색 유형 — 브루트포스 + 2D 패턴 매칭

tissue_0321 — Fri, 8 May 2026 16:42:16 +0900

격자판 슬라이딩 탐색 — 브루트포스 + 2D 패턴 매칭

1. 이 유형이 나오는 상황

두 개의 격자(grid)가 주어지고, 한 격자를 다른 격자 위에 겹쳐가면서 최적의 위치를 찾아야 할 때 등장한다.

핵심 질문은 항상 이것이다.

*"두 격자를 어떻게 겹쳐야 공통 원소가 최대가 되는가?"*

대표 문제:

동전 퍼즐 — 현재 배치 → 목표 배치로 만들 때 최소 이동 횟수
자물쇠와 열쇠 — 열쇠를 회전/반전해서 자물쇠에 맞추기

2. 핵심 아이디어 — 왜 "겹치기"인가?

동전 퍼즐을 예로 들면:

현재(vec1):    목표(vec2):
O . .          . O .
. O .          . . O

동전을 옮기는 최소 횟수를 구하려면 반대로 생각한다.

"이미 목표 위치에 있는 동전이 많을수록 → 옮길 동전이 적다"

따라서:

정답 = 전체 동전 수 - 최대한 겹쳤을 때의 동전 수

"최대한 겹친다"는 것이 곧 vec1을 고정하고 vec2를 모든 방향으로 밀어보는 것이다.

3. 오프셋(offset) — vec2를 밀어보는 방법

오프셋 (dy, dx) = vec2를 얼마나 이동할지를 나타내는 값이다.

dy=0, dx=1 일 때 (vec2를 오른쪽으로 1칸):

vec1:          vec2(이동 후):
O . .          . O .   ← dx=1이므로 열이 1씩 밀림
. O .          . . O

실제 코드에서는, vec1의 좌표에 오프셋을 더해 vec2의 좌표를 계산한다.

int h2 = h1 + dy;
int w2 = w1 + dx;
// vec1[h1][w1]이 vec2[h2][w2]와 겹치는지 확인

오프셋 범위는 왜 -H1+1 ~ H2-1 인가?

←── 완전히 벗어남 ──┬── 겹치는 구간 ──┬── 완전히 벗어남 ──→
                 │              │
           dy = -(H1-1)     dy = (H2-1)

vec1과 vec2가 단 한 칸이라도 겹칠 수 있는 모든 위치를 탐색하는 것이다.

4. 전체 코드 (오프셋 탐색)

동전 퍼즐 문제의 예시 코드를 살펴보자

int main() {
    int H1, W1;
    cin >> H1 >> W1;
    vector<string> vec1(H1);
    int totalCoins = 0;
    for (int i = 0; i < H1; i++) {
        cin >> vec1[i];
        for (char c : vec1[i])
            if (c == 'O') totalCoins++;
    }

    int H2, W2;
    cin >> H2 >> W2;
    vector<string> vec2(H2);
    for (int i = 0; i < H2; i++) cin >> vec2[i];

    int maxOverlap = 0;

    for (int dy = -H1 + 1; dy < H2; dy++) {
        for (int dx = -W1 + 1; dx < W2; dx++) {
            int overlap = 0;
            for (int i = 0; i < H1; i++) {
                for (int j = 0; j < W1; j++) {
                    int h2 = i + dy;
                    int w2 = j + dx;

                    // 범위 체크 필수
                    if (h2 >= 0 && h2 < H2 && w2 >= 0 && w2 < W2)
                        if (vec1[i][j] == 'O' && vec2[h2][w2] == 'O')
                            overlap++;
                }
            }
            maxOverlap = max(maxOverlap, overlap);
        }
    }

    cout << totalCoins - maxOverlap << endl;
    return 0;
}

자주 하는 실수

실수	증상
`dy < H2 - 1` 로 쓰기	마지막 케이스 탐색 누락
`vec2[i+dy][j+dx]` 범위 체크 없이 접근	런타임 에러 (index out of range)
H1, W1을 변환 후에도 그대로 쓰기	회전 후 크기가 바뀌는 경우 틀림

5. 변환 추가하기 — 회전 & 반전

자물쇠와 열쇠 같은 문제에서는 열쇠를 회전하거나 뒤집는 조건도 추가된다.

이 경우 vec1의 모든 변환 버전을 생성한 뒤, 각각에 대해 오프셋 탐색을 돌린다.

좌우 반전 (flipLR)

O . .          . . O
. O .    →     . O .
. . .          . . .

각 행(row)의 문자 순서를 뒤집는다.

vector<string> flipLR(vector<string>& v) {
    vector<string> res = v;
    for (auto& row : res)
        reverse(row.begin(), row.end());  // 문자 순서 반전
    return res;
}

상하 반전 (flipUD)

O . .          . . .
. . .    →     . . .
. . .          O . .

행(row)들의 순서를 뒤집는다.

vector<string> flipUD(vector<string>& v) {
    vector<string> res = v;
    reverse(res.begin(), res.end());  // 행 순서 반전
    return res;
}

90도 시계방향 회전 (rotate90)

O . .          . . O
. O .    →     . O .
. . .          . . .

중요: 회전하면 H×W → W×H 로 크기가 바뀐다.

vector<string> rotate90(vector<string>& v) {
    int H = v.size(), W = v[0].size();
    vector<string> res(W, string(H, '.'));  // W×H 크기로 새로 생성
    for (int i = 0; i < H; i++)
        for (int j = 0; j < W; j++)
            **res[j][H - 1 - i] = v[i][j];**
    return res;
}

변환식 `res[j][H-1-i] = v[i][j]` 유도 과정

시계방향 90도 회전은 두 단계로 나뉜다.

step 1. 행과 열을 교환:  (i, j)      → (j, i)
step 2. 열을 뒤집기:     (j, i)      → (j, H-1-i)

한 줄 요약:

열이 새 행이 되고, 원본 행은 뒤집혀서 새 열이 된다.

8가지 변환 생성 & 탐색

원본을 0°, 90°, 180°, 270° 회전하고, 각각에 좌우 반전을 적용하면 총 8가지 변환이 나온다.

vector<vector<string>> candidates;

vector<string> tmp = vec1;
for (int rot = 0; rot < 4; rot++) {
    candidates.push_back(tmp);           // 회전본
    candidates.push_back(flipLR(tmp));   // 회전본 + 좌우반전
    tmp = rotate90(tmp);                 // 다음 회전
}

// 각 변환에 대해 오프셋 탐색
for (auto& cand : candidates) {
    int H1 = cand.size(), W1 = cand[0].size();  // 크기 다시 계산!

    for (int dy = -H1 + 1; dy < H2; dy++) {
        for (int dx = -W1 + 1; dx < W2; dx++) {
            int overlap = 0;
            for (int i = 0; i < H1; i++) {
                for (int j = 0; j < W1; j++) {
                    int h2 = i + dy, w2 = j + dx;
                    if (h2 >= 0 && h2 < H2 && w2 >= 0 && w2 < W2)
                        if (cand[i][j] == 'O' && vec2[h2][w2] == 'O')
                            overlap++;
                }
            }
            maxOverlap = max(maxOverlap, overlap);
        }
    }
}

상하반전이 없는 이유

회전본
회전본 + 좌우반전
회전본 + 상하반전 ← ??
다음회전

상하반전이 다른 변환의 조합으로 만들어지기 때문에 만들지 않아도 된다

6. 풀이 전략 정리

1. vec1 고정, vec2를 모든 오프셋(dy, dx)으로 이동
2. 각 오프셋에서 O끼리 겹치는 개수 계산
3. 최대 겹침 = maxOverlap
4. 정답 = totalCoins - maxOverlap

회전/반전이 허용되는 경우:
  → vec1의 8가지 변환 버전 생성
  → 각 버전마다 동일하게 오프셋 탐색
  → 변환 후에는 H1, W1 크기를 반드시 다시 계산

7. 시간복잡도

조건	복잡도
기본 오프셋 탐색	$O((H1+H2) × (W1+W2) × H1 × W1)$
8가지 변환 포함	위의 8배

H1, H2, W1, W2가 크지 않은 경우(보통 50 이하)에 유효한 전략이다.

[알고리즘] 슬라이딩 윈도우

tissue_0321 — Fri, 8 May 2026 16:41:28 +0900

슬라이딩 윈도우란?

배열/문자열 위에 window를 올려놓고, 오른쪽으로 밀면서 탐색하는 기법이다.
완전탐색 $O(N²$) → $O(N)$ 으로 줄이는 게 핵심이다.

빈출 유형

연속된 구간에서 최대/최소/개수를 구할 때 등장한다

1) 고정 크기 윈도우

예) "크기 K인 연속 부분 배열의 최대 합"

창문 크기 K가 고정되어 있다.
right가 움직이면 left도 같이 움직인다.

2) 가변 크기 윈도우

예) "합이 S 이하인 가장 긴 연속 부분 배열", 개미 집합의 지름 문제

조건에 따라 창문 크기가 늘었다 줄었다한다.
left/right 독립적으로 움직인다.

3) 반대 방향 투 포인터

예) "두 수의 합이 target인 쌍 찾기", "3Sum"

정렬 후 left/right를 양 끝에서 좁혀오는 방식이다.
투 포인터가 슬라이딩 윈도우를 포함하는 더 큰 범위이다.

적용 가능한지 판단하는 기준

기준	설명
① 연속된 구간인가?	인덱스가 연속되어야 한다. 부분집합/순열이면 X
② 단조성이 있는가?	right 늘릴수록 값이 커지기만 해야 한다. 음수 포함 시 주의
③ left 복원 가능한가?	left 당기면 조건이 다시 만족되어야 한다.

하나라도 X면 슬라이딩 윈도우 적용이 어렵다

기록

개미 집합의 지름
- 처음 접근: 투포인터 그리디 (X)
  - 개미 집합의 지름 문제를 풀면서, 투포인터로 접근했다.
  - 매 순간 왼쪽/오른쪽 중 제거 시 더 많이 줄어드는 쪽을 제거하는 방식을 채택했다.
    → 그리디는 현재 최선만 보기 때문에 전체 최적을 보장하지 않음!!!!
    - 반례) 1 3 4 10, D=2
      그리디: 3번 제거 / 최적: 2번 제거 (1, 10 제거)
올바른 접근: 슬라이딩 윈도우 (O

[CS 스터디] 05. TCP 3-way / 4-way Handshake

tissue_0321 — Fri, 8 May 2026 14:30:23 +0900

1. TCP에 대해서

TCP 3-way / 4-way Handshake에 대해서 설명하기 위해, 기본적으로 TCP에 대해서 알아보자.

TCP/UDP는 전송 계층에서 사용하는 데이터 전송 기법(프로토콜)이다.
(TCP/IP의 4계층의 관점에서 주로 이야기한다)

여기서 TCP가 신뢰도 보장에 사용하는 기법이 3-way, 4-way handShake이다.
3-way는 연결을 시작할 때, 4-way는 연결을 끊을 때 사용된다.

오늘의 학습 포인트

TCP 3-way handshake를 설명하고, 왜 2-way가 아닌지 말해보기
4-way handshake에서 TIME_WAIT이 왜 필요한지 말해보기

2. TCP 연결 성립 과정

TCP는 신뢰성을 확보할 때 3-way handshake라는 작업을 진행한다.
클라이언트와 서버가 통신할 때 세 단계의 과정을 거치는 것이다.

1. "나 지금 연결할 준비됐어." — SYN
2. "나도 준비됐어, 네가 준비됐다는 거 확인했어." — SYN-ACK
3. "나도 네가 준비됐다는 거 확인했어." — ACK
⇒ 이렇게 신뢰성을 확보한 후 데이터 전송을 시작한다.

(1) ISN - 초기 시퀀스 번호

시퀀스 번호(ISN)는 데이터의 순서와 수신 확인에 사용되는 핵심 값이다.
TCP 연결을 수립하려면 클라이언트와 서버가 서로의 초기 시퀀스 번호(ISN, Initial Sequence Number)를 알아야 한다.
이 ISN은 임의로 생성되는 값이다.

(2) 연결 수립의 3단계

Step 1 — SYN: 클라이언트가 연결을 요청합니다

SYN 플래그 = 1 (연결 요청 표시)
Seq = 100 (클라이언트 ISN, 보안을 위해 랜덤 생성)
- ISN이 랜덤인 이유: TCP Session Hijacking 방지
클라이언트 상태: LISTEN → SYN_SENT

Step 2 — SYN-ACK: 서버가 요청을 수락하고 자신의 ISN을 제안합니다

SYN = 1 (서버도 자신의 ISN 제안)
ACK = 1 (클라이언트 SYN 수신 확인)
Seq = 200 (서버의 ISN)
Ack = 101 (Seq=100 받았음, 다음은 101 보내라)
서버 상태: LISTEN → SYN_RECEIVED

Step 3 — ACK: 클라이언트가 서버의 ISN을 확인합니다. 연결 수립 완료!

ACK = 1 (서버 SYN-ACK 수신 확인)
Seq = 101 (클라이언트 다음 전송 번호)
Ack = 201 (서버 Seq=200 받았음, 다음은 201 보내라)
양측 상태: → ESTABLISHED
이제 데이터 전송이 가능합니다

(3) 왜 2-way가 아닌 3-way인가?

이 질문은 단순히 "규칙이 그래서"가 아니라, 무엇이 잘못될 수 있는지를 설명할 수 있어야 한다.

2-way로 하면 SYN-ACK가 유실됐을 때 서버는 "연결이 수립됐다"고 판단하지만
클라이언트는 모르는 half-open 연결이 발생한다. 세 번째 ACK가 이 문제를 해결한다.

SYN-ACK를 보낸 서버는 클라이언트와 연결되었다고 착각하고,
유실된 SYN-ACK는 클라이언트에 도달하지 못한다.
응답을 받지 못한 클라이언트는 여전히 연결되지 않았다고 판단한다.

→ half-open 발생 (서버만 연결되었다고 믿고 기다리는 상황)
서버는 데이터가 오길 기다리며 불필요한 자원을 낭비하게 된다.

세 번째 ACK로 서버가 클라이언트의 수신을 확인한다.
half-open 연결이 발생하지 않는다.

3-way가 필요한 이유 요약

3. TCP 연결 해제 과정

(1) 4-way handshake

통신이 끝나고 TCP 연결 해제 시, 4-way handshake 과정이 발생한다.

전이중 통신

TCP는 전이중(Full-Duplex) 통신이다.
클라이언트→서버, 서버→클라이언트 두 방향의 채널이 독립적으로 존재한다.
따라서 연결을 끊을 때도 각 방향을 따로 닫아야 한다.

3way가 아닌 4way인 이유

연결 수립 시에는 서버가 SYN과 ACK를 하나의 패킷으로 합쳐 보낼 수 있었지만, 종료 시에는 불가능하다.
클라이언트가 종료(FIN)를 선언하더라도 서버는 아직 전송 중인 데이터가 남아 있을 수 있기 때문이다.

Step 1 — FIN: 클라이언트가 연결 종료를 요청합니다

FIN 플래그 = 1 (더 이상 보낼 데이터 없음)
클라이언트 상태: ESTABLISHED → FIN_WAIT_1
클라이언트→서버 방향만 닫힘 (Half-Close)
클라이언트는 여전히 서버 데이터를 수신할 수 있음

Step 2 — ACK: 서버가 FIN 수신을 확인합니다. 아직 데이터가 남을 수 있습니다

ACK = 1, Ack = 301 (FIN 수신 확인)
서버 상태: ESTABLISHED → CLOSE_WAIT
클라이언트 상태: FIN_WAIT_1 → FIN_WAIT_2
서버는 아직 보낼 데이터가 있을 수 있음 (Half-Close 유지)
이것이 4-way인 이유: ACK와 FIN을 즉시 합칠 수 없음

Step 3 — FIN: 서버가 모든 데이터 전송 완료 후 종료를 선언합니다

FIN 플래그 = 1
서버 상태: CLOSE_WAIT → LAST_ACK
서버→클라이언트 방향도 닫힘 예정
마지막 ACK를 기다리는 상태

Step 4 — ACK: 클라이언트가 서버 FIN을 확인. TIME_WAIT 시작!

ACK = 1, Ack = 501 (서버 FIN 확인)
서버 상태: LAST_ACK → CLOSED
클라이언트 상태: FIN_WAIT_2 → TIME_WAIT
TIME_WAIT: 2*MSL(약 120초) 대기 후 CLOSED
마지막 ACK 유실 대비 + 이전 패킷 혼동 방지

(2) TIME_WAIT

TIME_WAIT
- 마지막 ACK를 보낸 후 클라이언트는 즉시 포트를 닫지 않는 이유는 무엇일까?
  1. 첫째, 마지막 ACK가 유실될 경우 서버의 재전송 FIN을 처리하기 위해서입니다.
  2. 둘째, 이전 연결의 지연 패킷이 새 연결에 끼어드는 것을 방지하기 위해서입니다.
  → 연결 종료 시 신뢰성을 위해 마지막에 거치는 상태

마지막 ACK 유실 대비

TCP 연결을 종료할 때, 마지막 ACK(A가 B에게 보내는 확인 응답)가 네트워크상에서 사라질 수 있습니다.

상황:
- A가 마지막 ACK를 보내고 즉시 연결을 닫아버렸는데,
  이 ACK가 유실되었다고 가정해 보자.
상태:
- 상대방(B)은 본인이 보낸 FIN에 대한 응답을 받지 못했으므로, 다시 FIN을 재전송한다.
TIME_WAIT의 역할:
- 이때 A가 TIME_WAIT 상태로 남아있지 않고 이미 소켓을 닫았다면,
  재전송된 FIN에 대해 RST(오류) 응답을 보내게 된다. (정상적인 종료X)
해결:
- A가 TIME_WAIT 상태로 기다리고 있으면,
  다시 날아온 FIN에 대해 ACK를 다시 보내줄 수 있어 상대방이 연결을 종료할 수 있게 됩니다.

지연 패킷 차단

네트워크 경로 문제로 인해, 이전 연결에서 보낸 데이터 패킷이 아주 늦게 도착하는 경우가 있다.

위험성:
- 만약 연결 종료 직후 같은 포트 번호로 새로운 연결이 생겼는데,
  뒤늦게 도착한 옛날 패킷(지연 패킷)이 새 연결의 데이터인 것처럼 끼어들면 데이터 오염이 발생한다.
TIME_WAIT의 역할:
- TCP는 보통 2MSL(Maximum Segment Lifetime의 2배, 약 1~4분) 동안 해당 포트를 사용하지 못하게 묶어둔다.

질문 대비

Q: TIME_WAIT이 너무 많아지면 어떤 문제가 생길까요?

A: 서버 입장에서 TIME_WAIT 상태의 소켓이 너무 많아지면, 새로운 연결을 수립할 포트가 고갈될 수 있습니다. 그래서 실무에서는 이 시간을 튜닝하거나 포트를 재사용하는 설정을 쓰기도 합니다.

4. 비정상 종료 - RST 패킷

(1) RST 패킷이란?

연결을 즉각 종료하는 강제 종료 신호이다.
FIN을 통한 정상 종료와 달리,
버퍼에 남은 데이터를 버리고 양측 모두 즉시 CLOSED 상태로 전환한다.
TIME_WAIT 없이 즉각 종료되므로 포트 고갈 문제를 피할 수 있지만,
데이터 손실 위험이 있어 정상적인 상황에서는 사용하지 않는다.

(2) 언제 발생하나?

포트가 닫혀 있을 때: 클라이언트가 서버의 8080 포트로 연결을 시도했는데,
서버에서 그 포트를 안 쓰고 있다면 서버가 RST를 보낸다.
비정상적인 상태: 이미 연결이 끊긴 줄 모르고 데이터를 보냈을 때, 받는 쪽에서 RST를 날린다.
보안 장비의 개입: 방화벽이나 침입 차단 시스템(IPS)에서 유해한 통신이라고 판단하면, 양쪽에 RST를 보내서 강제로 연결을 끊어버린다.

5. 질문 답변

TCP 3-way handshake를 설명하고, 왜 2-way가 아닌지 말씀해주세요.
TCP는 데이터 전송 전 반드시 3-way handshake(SYN → SYN-ACK → ACK)를 수행합니다. 따라서 클라이언트가 서버의 응답을 잘 받았다는 세 번째 ACK를 보내줌으로써, 양방향 모두 통신 준비가 되었음을 확정하고 자원 낭비를 막는 것입니다.
2-way로는 충분하지 않은 이유는 half-open 연결 때문입니다. 2-way로 진행할 경우, 서버가 클라이언트의 요청에 응답(SYN-ACK)한 것만으로 서버는 연결이 되었다고 판단하지만, 만약 이 응답이 유실되면 클라이언트는 연결이 안 된 것으로 판단하는 Half-Open 상태가 됩니다. TCP 3-way handshake는 통신 전 양측의 상태를 확인하고 초기 시퀀스 번호(ISN)를 동기화하여 신뢰성 있는 연결을 맺는 과정입니다.
4-way handshake에서 TIME_WAIT이 왜 필요한지 말씀해주세요.
TIME_WAIT은 연결 해제의 안전장치 역할을 하며, 크게 두 가지 이유로 필수적입니다.
첫째, 마지막 ACK 유실에 대비하기 위해서입니다. 클라이언트가 보낸 마지막 ACK가 사라지면 서버는 FIN을 재전송하게 됩니다. 이때 클라이언트가 이미 소켓을 닫았다면 서버는 정상 종료를 못 하고 오류(RST)를 받게 됩니다. 반면 TIME_WAIT 상태가 있다면 재전송된 FIN에 다시 ACK를 보내주어 정상적인 종료를 보장할 수 있습니다.
둘째, 지연 패킷으로 인한 데이터 오염 방지입니다. 이전 연결에서 네트워크를 떠돌던 패킷이 나중에 생성된 동일한 포트의 새 연결에 도착할 경우, 데이터가 섞이는 문제가 발생할 수 있습니다. 이를 방지하기 위해 패킷의 최대 수명의 2배 동안 대기하여 잔여 패킷이 완전히 소멸되도록 기다리는 것입니다.
연결 해제 시 3-way handshake가 아닌, 4-way handshake인 이유에 대해서 말씀해주세요.
연결 시에는 서버가 클라이언트의 요청을 확인(ACK)함과 동시에 자신의 통신 준비(SYN)를 마칠 수 있어 하나의 패킷(SYN-ACK)으로 합칠 수 있습니다. 하지만 종료 시에는 클라이언트가 종료를 선언(FIN)하더라도, 서버는 아직 보낼 데이터가 남아있을 수 있습니다. 따라서 서버는 우선 수신 확인(ACK)만 보낸 뒤, 남은 데이터를 모두 전송한 후에 별도로 종료(FIN)를 선언해야 하므로 총 4단계가 필요합니다.

- 참고 자료: https://dev-letter.kr/

[KB IT's Your Life] 9주차 후기, 백엔드 개발을 위한 자바프로그래밍 후기

tissue_0321 — Thu, 7 May 2026 09:47:44 +0900

[9주차 수강 후기]

백엔드 개발을 위한 자바 프로그래밍

[KB IT's Your Life 7기] Java 멀티 스레드 완전 정복하기

안녕하세요! KB IT's Your Life 7기 기자단입니다

오늘은 Java에서 정말 중요한 개념 중 하나인 멀티 스레드(Multi Thread) 에 대해 정리해볼게요.

처음엔 좀 어렵게 느껴질 수 있지만, 차근차근 따라오시면 분명히 이해되실 거예요!

1. 멀티 스레드란?

먼저 기본 개념부터 짚고 갈게요.

우리가 프로그램을 실행하면 운영체제는 그 프로그램을 프로세스(Process) 단위로 관리해요.

그리고 그 프로세스 안에서 코드가 실행되는 흐름 하나하나를 스레드(Thread) 라고 부릅니다.

그렇다면 멀티 스레드는? 두 개 이상의 코드 실행 흐름을 동시에 처리하는 것이에요!

멀티 프로세스 = 프로그램 단위의 멀티 태스킹

멀티 스레드 = 프로그램 내부에서의 멀티 태스킹

2. 메인 스레드 (Main Thread)

Java 프로그램은 실행되면 가장 먼저 메인 스레드 가 시작돼요.

메인 스레드는 main() 메소드의 첫 코드부터 순차적으로 실행되고, 마지막 코드를 실행하거나 return 문을 만나면 종료됩니다.

여기서 재미있는 점이 하나 있는데요!

메인 스레드가 먼저 종료되더라도, 작업 스레드가 아직 실행 중이라면 프로세스는 종료되지 않아요.

즉, 모든 스레드가 끝나야 비로소 프로그램이 끝나는 거랍니다.

3. 작업 스레드 생성과 실행

그럼 실제 코드로 어떻게 작업 스레드를 만드는지 살펴볼까요?

방법은 크게 두 가지예요.

방법 1. Thread 클래스로 직접 생성 (Runnable 이용)

Runnable 인터페이스를 구현한 객체를 만들어서 Thread 생성자에 넘겨주는 방식이에요.

// Runnable 구현 클래스 작성
class Task implements Runnable {
    @Override
    public void run() {
        // 스레드가 실행할 코드
    }
}

// Thread 생성 및 실행
Runnable task = new Task();
Thread thread = new Thread(task);
thread.start();

익명 객체를 바로 넘겨줄 수도 있어요!

Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        // 스레드가 실행할 코드
    }
});
thread.start();

방법 2. Thread 자식 클래스로 생성

Thread 클래스를 상속받아 run() 메소드를 재정의하는 방법도 있어요.

public class WorkerThread extends Thread {
    @Override
    public void run() {
        // 스레드가 실행할 코드
    }
}

Thread thread = new WorkerThread();
thread.start();

두 방법 모두 start()를 호출해야 스레드가 실제로 실행된다는 점!

잊지 마세요 ㅎㅎㅎㅎ

4. 스레드 상태 (Thread State)

스레드는 생성되고 나서 여러 상태를 거쳐요.

크게 세 가지로 나눌 수 있어요.

실행 대기 상태 (RUNNABLE)

→ start()를 호출하면 실행을 기다리는 상태가 됩니다.

실행 상태

→ CPU 스케줄링에 따라 CPU를 점유하고 run() 메소드를 실행하는 상태예요.

스케줄링에 의해 실행 대기 상태와 실행 상태를 왔다 갔다 반복하게 됩니다.

종료 상태 (TERMINATED)

→ run() 메소드가 끝나면 스레드도 종료돼요.

그 사이에 일시 정지 상태 도 있어요.

스레드가 잠깐 멈춰야 할 때 사용하는 상태인데,

이때 자주 쓰이는 메소드들이 있어요!

메소드 설명

sleep(long millis)	지정한 시간만큼 일시 정지, 이후 자동으로 실행 대기 상태로 복귀
join()	다른 스레드가 종료될 때까지 기다림
wait()	동기화 블록 내에서 일시 정지
interrupt()	일시 정지 상태인 스레드에 InterruptedException 발생
yield()	실행 상태에서 다른 스레드에게 실행을 양보

5. 스레드 동기화 (Synchronization)

멀티 스레드 환경에서 가장 주의해야 할 것이 바로 동기화 문제 예요.

여러 스레드가 동시에 같은 객체의 데이터를 변경하려고 하면, 엉뚱한 결과가 나올 수 있거든요.

이를 방지하기 위해 synchronized 키워드를 사용합니다!

스레드 작업이 끝날 때까지 객체에 잠금을 걸어, 다른 스레드가 중간에 끼어들 수 없도록 막는 거예요.

// 동기화 메소드
public synchronized void method() {
    // 단 하나의 스레드만 실행 가능한 영역
}

// 동기화 블록
public void method() {
    synchronized(공유객체) {
        // 단 하나의 스레드만 실행 가능한 영역
    }
}

또한 두 스레드가 번갈아가며 작업할 때는 wait()과 notify()를 활용해요.

한 스레드가 작업을 마치면 notify()로 대기 중인 스레드를 깨우고, wait()으로 자신은 일시 정지 상태가 되는 방식이에요.

6. 스레드풀 (Thread Pool)

마지막으로 스레드풀 에 대해 알아볼게요!

작업이 폭발적으로 늘어날 때마다 스레드를 새로 만들면 성능이 급격히 떨어질 수 있어요.

이 문제를 해결해주는 게 바로 스레드풀이에요.

스레드풀은 미리 정해진 수의 스레드를 만들어두고, 들어오는 작업을 큐에 쌓아서 스레드들이 하나씩 꺼내 처리하는 방식이에요.

작업량이 늘어도 스레드 수가 일정하게 유지되니까 안정적으로 운영할 수 있죠!

Java에서는 java.util.concurrent 패키지의 ExecutorService와 Executors 클래스를 통해 간편하게 만들 수 있어요.

// 방법 1. 캐시 스레드풀 (필요에 따라 스레드 생성)
ExecutorService executorService = Executors.newCachedThreadPool();

// 방법 2. 고정 스레드풀 (5개 고정)
ExecutorService executorService = Executors.newFixedThreadPool(5);

사용이 끝나면 반드시 종료해줘야 해요!

executorService.shutdown();     // 현재 작업 처리 후 종료
executorService.shutdownNow();  // 즉시 중단

마무리

오늘은 Java 멀티 스레드의 핵심 개념들을 정리해봤어요!

멀티 스레드 = 하나의 프로그램 안에서 여러 작업을 동시에 처리하는 것

스레드 생성 = Thread 클래스 직접 생성 또는 자식 클래스로 생성

스레드 상태 = 실행 대기 → 실행 → 일시 정지 → 종료 사이를 순환

동기화 = synchronized로 공유 데이터를 안전하게 보호

스레드풀 = 스레드 수를 고정해 안정적인 성능 유지

처음엔 개념이 복잡하게 느껴질 수 있지만, 직접 코드를 작성하면서 연습하다 보면 점점 익숙해질 거예요!

다음 포스팅에서도 유익한 내용으로 돌아올게요

#멀티캠퍼스부트캠프후기 #멀티캠퍼스부트캠프 #KBITSYOURLIFE #KB국민은행부트캠프 #KB부트캠프 #KBIT교육

[KB IT's Your Life 7기] 8주차 후기,Java - 중첩 선언과 익명 객체

tissue_0321 — Tue, 28 Apr 2026 10:51:04 +0900

어느덧 8주차가 되었습니다

시간이 정말 빠르게 가고 있어서...

벌써 반이 넘게 지나간 것 같은 기분이에요

이번 주는 내용이 꽤 묵직했습니다

SOLID 원칙, 템플릿 메서드 패턴, 그리고 중첩 클래스와 익명 객체까지

한 주에 이 내용들을 다 소화해야 하니까

솔직히 머릿속에서 정리가 잘 안 됐던 순간들이 꽤 있었어요

그래도 하나씩 짚어보면서 "아, 이래서 쓰는 거구나!" 싶은 순간이 생기니까

그 맛에 공부하는 것 같습니다 ㅎㅎ

SOLID 원칙

가장 먼저 SOLID 원칙을 배웠는데요

객체지향 설계에서 기본 중의 기본이라고 할 수 있는 내용이에요

다섯 가지 원칙이 있는데, 이름도 외울 겸 정리해봤습니다

S - 단일 책임 원칙 (Single Responsibility)

하나의 클래스는 하나의 책임만 가져야 합니다

O - 개방 폐쇄 원칙 (Open/Closed)

확장에는 열려있고, 수정에는 닫혀 있어야 합니다

기존 코드를 건드리지 않고 새 기능을 추가할 수 있어야 한다는 말이에요

L - 리스코프 치환 원칙 (Liskov Substitution)

부모 타입 자리에 자식 타입을 넣어도 정상적으로 동작해야 합니다

업캐스팅을 해도 문제없이 돌아가야 한다는 의미인데,

개방 폐쇄 원칙을 받쳐주는 다형성 원칙이라고 이해했어요

I - 인터페이스 분리 원칙 (Interface Segregation)

클라이언트는 자신이 사용하는 메서드에만 의존해야 합니다

인터페이스를 너무 뚱뚱하게 만들지 말고, 사용하는 쪽 기준으로 잘게 나누라는 뜻이에요

D - 의존 역전 원칙 (Dependency Inversion)

고수준 모듈이 저수준 모듈의 구현에 직접 의존하면 안 됩니다

추상화(인터페이스)에 의존하도록 설계해야 한다는 원칙이에요

이 원칙들, 각각 따로따로 들을 때는 "그렇구나~" 싶은데

실제 코드에 적용하려면 또 다른 이야기더라구요

머리로는 아는데 손이 안 따라오는 그 느낌...

익숙해지는 수밖에 없는 것 같습니다

템플릿 메서드 패턴

다음은 디자인 패턴 중 하나인 템플릿 메서드 패턴(Template Method Pattern) 입니다

한마디로 정리하면,

부모 클래스에서 알고리즘의 뼈대를 정하고, 세부 구현은 자식 클래스에서 채운다

이 패턴이 왜 좋냐면, 공통 로직을 부모 클래스에 몰아넣을 수 있어서

자식 클래스들이 일일이 같은 코드를 반복하지 않아도 된다는 점이에요

실제 프레임워크 내부에서도 이 패턴이 많이 쓰인다고 하는데

"아, 그래서 상속이 중요한 거구나" 하고 다시 한번 느꼈어요

중첩 클래스와 익명 객체

이번 주 내용 중에서 가장 신선했던 파트였어요!!!

중첩 클래스란?

클래스 안에 또 다른 클래스를 선언하는 것입니다

크게 세 가지로 나뉘어요

인스턴스 멤버 클래스

바깥 클래스의 멤버로 선언되는 클래스예요

특징은, 바깥 객체(A)를 먼저 생성해야만 안쪽 클래스(B) 객체를 만들 수 있다는 것!

정적 멤버 클래스

static 키워드가 붙은 중첩 클래스예요

인스턴스 멤버 클래스와의 핵심 차이는 바깥 객체 없이 바로 생성 가능하다는 점입니다

여기서 중요한 포인트!!

static class B에서 static이 "B 객체가 하나만 만들어진다"는 뜻이 아니에요

"B 설계도를 사용하는 데 바깥 객체가 필요 없다"는 의미입니다

그래서 new를 자유롭게 써서 여러 개 만들 수 있어요

로컬 클래스

생성자나 메서드 내부에서만 선언되는 클래스예요

해당 메서드 실행 중에만 존재하고, 접근 제한자도 붙일 수 없어요

(메서드 안에서만 쓰이니까 의미가 없기 때문!)

그래서 중첩 클래스를 왜 쓰나요?

실무 예시가 꽤 와닿았어요

안드로이드/GUI의 이벤트 리스너: 버튼 클릭 로직은 그 화면 안에서만 의미가 있으니까, 익명 객체나 중첩 클래스로 처리
자료구조의 Node: LinkedList나 Tree를 만들 때, Node 클래스는 외부에서 직접 쓸 일이 없으니 private static class Node로 숨겨버림

외부에 노출할 필요 없는 클래스를 안쪽에 감춰서 코드 복잡성을 줄인다는 게 핵심인 것 같아요

바깥 객체 접근하기

중첩 클래스 안에서 바깥 클래스에 접근할 때는 바깥클래스이름.this를 사용합니다

void print() {
    System.out.println(this.field);   // 내 자신(B)의 필드
    System.out.println(A.this.field); // 바깥(A)의 필드
}

B와 A에 같은 이름의 변수가 있을 때 구분하는 방법이에요!

이거 처음 봤을 때 되게 신기했습니다ㅋㅋㅋ

익명 객체 ⭐

이번 주 하이라이트!!

익명 자식 객체 - 클래스를 상속받아 즉석에서 만드는 방식

Tire tire = new Tire() {
    @Override
    public void roll() {
        System.out.println("익명 자식 Tire 객체가 굴러갑니다.");
    }
};

익명 구현 객체 - 인터페이스를 즉석에서 구현하는 방식

btn.setClickListener(new Button.ClickListener() {
    @Override
    public void onClick() {
        System.out.println("클릭!");
    }
});

원래 인터페이스는 new 자체가 불가능한데,

{} 블록을 붙여서 "이 자리에서 이름 없는 구현 클래스를 즉석으로 만들겠다"는 선언을 하는 거예요

그래서 '익명 객체'라고 부르는 거고요

매번 클래스 파일을 따로 만들지 않아도 된다는 점에서 굉장히 편리한 것 같아요

안드로이드나 UI 이벤트 처리에서 많이 쓰인다는 게 바로 이해가 됐습니다!!

익명 구현 객체 vs 익명 객체

공부하다보니 익명 구현 객체와, 익명 객체의 차이점이 궁금하더라구요

대략 이런 차이점이 존재했습니다!

마무리

이번 주는 솔직히 양이 꽤 많아서 정리하면서도 머리가 핑핑 돌았어요

특히 중첩 클래스 파트에서 인스턴스 멤버 / 정적 멤버 / 로컬 클래스 세 가지를 구분하는 게

처음에는 헷갈렸는데, 핵심 기준이 "바깥 객체 필요 여부"라는 걸 파악하고 나서 정리가 됐습니다

그리고 익명 객체는... 처음엔 왜 쓰나 싶었는데

막상 활용 사례 보니까 "이거 람다랑 비슷한 느낌이다!" 싶었어요

나중에 람다 배우면서 다시 복습하게 될 것 같은 예감이 듭니다 ㅎㅎ

그동안 수업 들으면서 노션에 열심히 정리했는데

벌써 이만큼 쌓인거 보니 ... 그래도 시간이 많이 지나긴 했네요

이제 java쪽 배우면서 부족한 부분을 많이 보완할 수 있을 것 같습니다!

다음 주차도 열심히 소화해볼게요

KB IT's Your Life 수료까지 아자좟!!!!!

TiLog

[KB IT's Your Life 7기] 14주차 교육 후기: JDBC

[KB IT's Your Life 7기] 13주차 후기 - MYSQL과 DBMS

[KB IT's Your Life 7기] 12주차 후기 - 코딩테스트 준비

[KB IT's Your Life 7기] 12주차 후기 - 코딩테스트 준비

1. 재귀 (Recursion)

2. 그리디 (Greedy)

3. 완전 탐색 (Brute Force)

4. 잠깐! 지난 시간 복습 - BFS와 DFS

5. 예시 문제 풀어보기 - 프로그래머스 : 양과 늑대

문제 설명

풀이 핵심 아이디어

️ C++ 풀이 코드

코드 흐름 정리

6. 이번 주 느낀 점 ✍️

[KB IT's Your Life 7기] 11주차 후기, 코딩 테스트 자료 구조

[11주차 후기, 코딩 테스트 자료 구조]

[문제 풀이]

[KB IT's Your Life] 10주차 후기, 람다

[10주차 수강 후기]

[알고리즘] 격자판 슬라이딩 탐색 유형 — 브루트포스 + 2D 패턴 매칭

격자판 슬라이딩 탐색 — 브루트포스 + 2D 패턴 매칭

1. 이 유형이 나오는 상황

2. 핵심 아이디어 — 왜 "겹치기"인가?

3. 오프셋(offset) — vec2를 밀어보는 방법

오프셋 범위는 왜 -H1+1 ~ H2-1 인가?

4. 전체 코드 (오프셋 탐색)

자주 하는 실수

5. 변환 추가하기 — 회전 & 반전

좌우 반전 (flipLR)

상하 반전 (flipUD)

90도 시계방향 회전 (rotate90)

변환식 res[j][H-1-i] = v[i][j] 유도 과정

8가지 변환 생성 & 탐색

상하반전이 없는 이유

6. 풀이 전략 정리

7. 시간복잡도

[알고리즘] 슬라이딩 윈도우

슬라이딩 윈도우란?

빈출 유형

1) 고정 크기 윈도우

2) 가변 크기 윈도우

3) 반대 방향 투 포인터

적용 가능한지 판단하는 기준

기록

[CS 스터디] 05. TCP 3-way / 4-way Handshake

1. TCP에 대해서

오늘의 학습 포인트

2. TCP 연결 성립 과정

(1) ISN - 초기 시퀀스 번호

(2) 연결 수립의 3단계

(3) 왜 2-way가 아닌 3-way인가?

3-way가 필요한 이유 요약

3. TCP 연결 해제 과정

(1) 4-way handshake

전이중 통신

3way가 아닌 4way인 이유

(2) TIME_WAIT

마지막 ACK 유실 대비

지연 패킷 차단

질문 대비

4. 비정상 종료 - RST 패킷

(1) RST 패킷이란?

(2) 언제 발생하나?

5. 질문 답변

[KB IT's Your Life] 9주차 후기, 백엔드 개발을 위한 자바프로그래밍 후기

[KB IT's Your Life 7기] Java 멀티 스레드 완전 정복하기

1. 멀티 스레드란?

2. 메인 스레드 (Main Thread)

3. 작업 스레드 생성과 실행

방법 1. Thread 클래스로 직접 생성 (Runnable 이용)

방법 2. Thread 자식 클래스로 생성

4. 스레드 상태 (Thread State)

5. 스레드 동기화 (Synchronization)

6. 스레드풀 (Thread Pool)

마무리

[KB IT's Your Life 7기] 8주차 후기,Java - 중첩 선언과 익명 객체

SOLID 원칙

템플릿 메서드 패턴

중첩 클래스와 익명 객체

변환식 `res[j][H-1-i] = v[i][j]` 유도 과정