LOV3

[OS 공룡책] 6. Synchronization Tools, 7. Examples

grammiboii — Fri, 9 Jan 2026 19:10:08 +0900

동시 접근이 일어나면 항상 발생하는 문제가

data inconsistency - 일관성 문제이다

JVM에서 공부했던 내용이라 간략하게만 언급하면

스레드는 메모리를 공유하기 때문에 - 정확하게는 힙 영역을 공유하기 때문에 발생한다

c언어 예시이긴 하지만

sum++이 결국 sum (현재 값을 읽고->증가된 값 쓰기) 로직이니까

동시에 접근하는 값이 최신 값이 아니게 되면서 정합성이 깨지기 시작한다

자바 고급1에서 너무 많이했으니 패스

Race Condition

한국어로 교착상태

여러개의 프로세스가 하나의 값 수정을 할때 발생하는 문제

교착상태가 발생하는 코드 구역을 ciritical section이라고 부르는데

세부적으로 코드 영역을 4가지로 구분한다

여기서는 아직 락을 배우지 않았지만 언급하겠다

- entry section

require permission - 락을 획득해야 진입할 수 있는 구간

- critical section

임계영역으로 race condition이 발생하는 구간

- exit section

ciritical section이 끝나는 구간으로 락을 반납해야할 것이다

- remainder section

나머지~

이때 critical section 문제를 해결하기 위한 3가지 요구사항이 있다

- mutual exclusion

상호 배제

하나의 프로세스가 critical section을 실행하고 있다면 다른 프로세스는 실행할 수 없어야 한다

- progress (avoid deadlock)

프로세스가 critical section을 실행하고 있지 않음에도

다른 프로세스가 진입하지 못하는 경우가 없어야 한다

- bounded waiting (avoid starvation)

락을 획득하기 위해 기다리는 프로세스들이 있을텐데

락 획득에 우선순위를 둔다면 cpu scheduling때와 마찬가지로 우선순위에 계속 밀려 락을 획득하지 못하는 경우가 없어야 한다

우선 mutual exclusion은 너무 필수적인거고

아래 두가지를 모두 발생하지 않도록 하는 것은 매우 어렵다

그래서 이게 발생했을 때 어떻게 할것인지가 중요한 포인트

single core에서는 문제를 해결하는 것이 간단하다

읽기 -> 더하기 -> 더한값 쓰기

수행될 동안 interrupt되지 않도록 하면 된다

즉 atomic하게 수행하면 된다

반면에 코어가 여러개라면 다른 코어에서 실행하는 경우도 문제가 되고

처리가 오래 걸린다면 코어가 놀게되는 즉 cpu utilization 문제가 발생한다

Peterson's Solution

soft ware based로

원시적인 락을 건거다

하지만 이 방법은

while 문을 도는 busy waiting 즉 spin lock이라는 문제점이 있다

Hardware based solutions

결국 하드웨어를 다뤄야 한다

- memory barriers or fences

- hardware instructions

- atomic variables

이 내용은 보너스 느낌으로 나온 것 같다

살짝 복기해보면

자바 고급편에서는 이런 자료형이나 CAS 연산은 살짝만 알아보고

이를 활용하는 concurrent 컬렉션을 알아봤었다

본격적으로 OS 레벨의 락은 이제 나온다

Mutex Locks

mutual exclusion을 줄여서 mutex

락을 획득하고, 반납하는 구조

아까 나온 peterson이랑 사실은 비슷하다

이것도 문제점이

- spinlock (context switch 비용을 아낄수는 있다)

- n개를 처리할 수 없다

- interrupt를 차단할 수 없다면 문제가 발생한다(멀티코어)

Semaphore

세마포어는 신호기라는 말이다

실제 구현에서는 그냥 integer 변수다

전에 나온 mutex와 차이점은

mutex에서는 락하나를 두고 받고, 반납하는 방식인데

여기서는 전역변수를 증가, 감소하는 방식을 사용하는 것이다

구현차이

- binary semaphore를 사용한다면 즉 0, 1만 사용하면 mutex와 같은 것이다

- counting semaphore

n개를 사용 가능

~~구체적으로~~

~~wait(), signal()을 사용하게 되는데~~

~~여기부터 락 획득을 대기하는 wait set 개념이 나오게 되는 것이다~~

~~이로 인해 waiting queue에 들어가게 되면 busy waiting 문제도 해결된다~~

~~이건 semaphore 구현 방식 중에서도 차이가 있는거라 지금 논점은 mutex -> semaphore -> monitor 발전이니까 생각하지 말자~~

뮤텍스 / 세마포어를 사용한다면

timing error가 발생할 수 있다

간단한 예시로

wait -> signal 순서만 헷갈려도 심각한 에러가 날 가능성이 존재한다

Monitor

이를 해결하기 위해 간단하게 사용 가능한 고 수준으로 동기화를 다룰 수 있는 모니터를 제공한다

특히 생산자, 소비자 문제에서

어떤 그룹을 깨울지에 대한 문제가 생기는걸 확인했었다

이를 위해 conditional variable이 필요하다

이런식으로

자바에서 제공하는 모니터락

객체마다 가지고 있었던 모니터락 기억나쥬?

대표적으로 두가지가 있다

- synchronized

객체 단위로 임계영역/메서드를 묶어주는 키워드였다

- wait(), notify()
Object 클래스에 선언되어서 모든 객체가 가지고 있다

wait() 메서드로 모니터락 획득하러 대기 (ready queue)

notify()는 락을 반납하면서 해당 wait set에 있는 스레드 깨움

좀 헷갈려서 비교해달라고 했더니 이렇다고 한다

Liveness

뮤텍스 / 세마포어 / 모니터 모두 mutual exclusion 문제를 해결하지

deadlock, starvation 문제를 고려하지 않는다

이를 고려한 것이 liveness

자세하게 알 필요는 없다고 하고

데드락/starvation은 뒤에서 자세히 나온다

동시성 제어 문제 실질적인 문제들을 다룬다

- bounded-buffer problem

전에 살펴봤던 생산자 소비자 문제

- readers-writers problem

여러개의 프로세스들이 shared data에 접근하는 것은 동일하지만 어떤 프로세스는 read만, 어떤 프로세스는 read+write 한다는 가정이 다르다

data inconsistency를 일으키는건 writer이기 때문에 writer에게 우선적으로 락을 점유할 기회를 줄것인지, reader writer 모두 공평하게 락을 획득할 기회를 줄것인지에 대한 고민이 존재한다 -> 현재는 Redaer Writer Locks라는 표준화된 해결 기법이 존재하기 때문에 개발자는 고민하지 않아도 된다고 한다

- dining-philosophers problem

대표적인 동기화 문제인데 철학자 5명 사이에 젓가락이 하나씩 5개가 있다는 가정하에 생기는 문제다

단순히 생각하면 젓가락을 동시에 집지 못하도록 락을 걸어 mutual exclusive하게 하면 되는거 아닌가? 이지만

동시에 모든 철학자가 자신 기준 왼쪽 젓가락을 잡는다면? - deadlock

1, 2, 3, 4, 5순으로 원형으로 앉아있다고 하면

1, 3이 밥을 번갈아 가면서 먹으면 철학자 2는 영원히 밥을 먹지 못할 것이다 - starvation

해결책으로

왼쪽 오른쪽 젓가락을 모두 집을 수 있을때만 집는 방법을 떠올릴 수 있다

-> 구체적으로 모니터를 사용해 이를 해결하는 법을 알아보자

젓가락을 드는 메커니즘이 원래는

thinking (젓가락 사용X) -> eating (젓가락 사용)

인데 hungry 상태를 추가해

thinking -> hungry -> eating 상태로 관리한다

hungry 상태는 락을 점유하기 위해 기다리는, wait set을 떠올리면 된다

이렇게 하면 mutex, deadlock은 방지할 수 있지만

starvation을 방지할 수는 없다

CAP이론처럼 여기서도 3가지(mutex, deadlock, starvation)를 모두 달성하기는 매우 어렵기 때문에

[OS 공룡책] 5. CPU Scheduling

grammiboii — Fri, 9 Jan 2026 18:10:53 +0900

하나의 cpu를 왜 sharing 해야하는지는 처음에 알아봤다

복습해보면

전제는 cpu는 굉장히 빠르기 때문에 처리량에 비해 놀고 있는 상황이고,

cpu utilization 즉 사용량을 극대화 하기 위해 여러가지 프로세스를 번갈아 가며 처리하기 위함

이는 기본적으로 IO bound가 cpu bound보다 훨씬 길기 때문에 발생한다

이제 cpu를 어떤 프로세스에게 어떻게 분배할것인가? 가 스케줄링이다

좀더 구체적으로 ready queue에 들어가있는 프로세스들에게 어떻게 할당할것인가?

크게 두가지가 있는데

- FIFO Queue

- Priority Queue

그리고 구체적인 방법론을 이해하기 위해

- Preemptive 선점형

- Non-preemptive 비선점형

개념이 나온다

이게 말이 좀 헷갈리는데

주체는 cpu 스케줄러이다

cpu 스케줄러가 preemptive하면 즉 선점형이면

현재 돌아가고 있는 프로세스들을 쫓아낼 수 있는 것이고

non preemptive하면 한번 점유한 프로세스는 자발적으로 끝나거나 waiting 상태가 될때까지 돌아간다는 것

그리고 하나더 몰랐던건

context switching때 switch할 다음 작업을 선택하는 것이 스케줄러이고

선택된 작업을 프로세서에게 할당하는 것은 dispatcher라고 따로 있다고 한다

다시 본론으로 돌아와 스케줄링할때 가장 중요한 지표는

- waiting time

- turnaround time

들어가기 앞서

좀 당연해보이지만 헷갈리는 부분은

프로세스를 기준으로 스케줄링한다고 배우는데

실질적으로는 스레드 단위로 스케줄링 하는게 일반적이라고 한다

스케줄링 알고리즘

간단하게 목록부터 보면

- FCFS : first come first served (Non - preemptive)

- SJF / SRTF : Shortest Job First / Shortest Remaining Time First (Non - preemptive / preemptive)

time sharing

- RR : Round Robin

- Priority Based

- MLQ : Multi Level Queue

- MLFQ : Multi Level Feedback Queue

FCFS

가장 간단하다

fifo 큐에 넣어주면 된다

Non - preemptive

waiting time

P1 : 0

P2 : 24

P3 : 27

평균 17초를 기다린다

turn around time

P1 : 24

P2 : 27

P3 : 30

완료될때까지 평균 27초

waiting time
P1 : 6

P2 : 0

P3 : 3

평균 3초를 기다렸다

P1 : 30

P2 : 3

P3 : 6

완료될때까지 평균 13초

들어오는 순서만 바뀌었는데 엄청난 차이가 난다

근본적으로 실행시간이 짧은데도 오래 기다려야 하기 때문에 이런 일이 발생한다

SJF Shortest Job First & SRTF Shortest Remaining Time First

위 문제를 해결하기 위해 실행시간이 가장 짧은 프로세스를 실행하는 아이디어

Non - preemptive OR preemptive

도착 순서와 무관하게 하나의 간트차트가 나온다

waiting time

P1 : 3

P2 : 16

P3 : 9

P4 : 0

평균 7초

왜 preemptive일수도 있는가

P1이 5초 작업이 걸리고

P2가 1초 작업이 걸리는데 P1을 1초 실행중에 P2가 들어온다면

P1 -> P2 -> P1순으로 작업할 수도 있다

이게 SRTF이다

RR Round Robin

CS에서 되게 많이 나오는 말인데 빙글빙글 돈다

그냥 고루고루 돌아가면서 쓰는 방식

preemptive - time sharing

그냥 time quantum

단위시간동안 쓰고 돌아가는 방식이다

보통 10 ~ 100 ms사이를 사용한다고 한다

구현은 circular queue사용

time quantum을 얼마로 두느냐가 굉장히 중요한 알고리즘

너무 적게 줘도 turn around time이 늘어나고

넘누 많이 줘도 문제다

Priority Based

프로세스에 우선순위를 부여해 실행하는 방식이고

모든 프로세스 우선순위가 같다면 FCFS 순으로 먼저 들어온 프로세스를 먼저 처리한다

SJF가 일종의 priorioty based라고 볼 수 있다

-> SJF에서 next cpu burst를 예상해 계산하기 때문 (수행 시간을 우선순위로 두는 것)

이 알고리즘에서는 starvation 문제가 발생할 수 있다

(우선순위가 높은것만 계속 실행하는 문제)

이를 해결하기 위해 aging을 사용할 수 있다

실행하지 못한 프로세스의 우선순위를 높여주는 방법

또한 여기서 preemptive하게 할것인가 non-preemptive하게 할것인가 선택이 존재한다

결론적으로 RR + Priority 섞어서 사용하게 되는데

같은 우선순위를 가지면 RR

[OS 공룡책] 4. Thread & Concurrency

grammiboii — Thu, 8 Jan 2026 23:32:36 +0900

하나의 프로그램에서도 여러가지 동작을 동시에 수행할 수 있다는 점에서 스레드가 필요하다

spring을 배우면서 그렇게 했던 스레드풀, 스택영역 등..이 이제 여기와 관련된 내용

멀티스레딩을 하면 좋은점은

- Responsiveness

연속적인 응답을 가능하게 한다

- Resource Sharing

스레드는 프로세스와 달리 메모리 공간을 공유하기 때문에 shared-memory나 message passing 방식보다 훨씬 쉽다

좀더 정확히는 JVM 구조 공부했을 때처럼 힙영역, 메서드 영역을 공유한다고 보면 될 것 같다. (Thread Local같은 예외도 있다)

- Economy

프로세스 생성보다 훨씬 저렴하다

context swithching보다 thread switching이 overhead가 훨씬 적다

- scalability

하나의 프로세서에서는 이 멀티스레딩 구조가 쉬울텐데, 현대에는 멀티코어 시스템을 사용하기 때문에 훨씬 더 복잡해진다

즉, 여러개의 스레드가 물리적으로 동일한 시간에 돌아가는 parallel한 개념이 나오기 때문에 동시성 문제가 더 생기는 것

-> 이게 자바 고급편에서 주로 다뤘던 내용이다

어떤 문제가 생기냐면

- identifying tasks

일을 쪼개서 각 스레드에게 어떤 일을 시킬것인지

- balance

각 스레드에게 얼마나 일을 쪼개서 시킬것인지

- data splitting

- data dependency

- test and debugging

+ 분산시스템이 나오면서 이게 더 복잡해졌다고 첨언도 나온다,, 저번 학기에 지겹게 배웠던 분산시스템..

스레드 종류

- user thread

java에서 일반적으로 사용하는 스레드를 예시로 들 수 있겠다

- kernel thread

시스템에 접근하기 위해 사용하는 native thread

다른 내용은 다 배운 기억이 잘 나는데 이건 기억이 전혀 안난다..? 기억을 못하는건가

이건 좀 자세하게 알아보자

user thread와 kernel thread의 관계에서는

- many to one model

커널 스레드 하나가 여러개의 유저 스레드를 매핑

- one to one model

하나의 커널 스레드가 하나의 유저 스레드를

- many to many model

이러면서 어플리케이션에서 커널 스레드를 쉽게 다루기 위한 pthread 개념이 나온다

유닉스 계열에서는 Posix thread이고

윈도우는 자체 윈도우 스레드가 있다고 한다

many to one 방식은 비효율적이고 멀티코어를 사용하기 힘들기 때문에 잘 사용하지 않고

대표적으로

자바에서 사용하는 방식이 one to one이고

GO언어에서 사용하는 방식이 many to many라고 한다

그럼 자바에서 스레드를 하나 늘릴때마다 OS 스레드도 하나 늘어나게 되는거고..

--> 너무 당연히 one to one이라고 생각했던 나를 반성하게 되는게

모니터링할때 os에 떠있는 스레드 개수가 스레드풀 개수랑 비슷하겠지라고 생각했다

이게 지금은 맞는 말이지만

만약 many to many 방식을 사용한다면 OS 스레드 개수는 서버의 스레드풀 개수에 비해 훨씬 적었을 것 같다

--> 이와 관련해 JAVA21에서 virtual thread 기능이 추가되었다고 한다

go routine처럼 many to many 매핑이 가능하다고 하는데,,

여태까지 왜 17썼지..? 정확하지는 않으니 나중에 따로 정리해보자

[OS 공룡책] 3. Process

grammiboii — Wed, 7 Jan 2026 00:33:48 +0900

OS를 다 까먹어서 복습해보기로.

1, 2챕터는 인트로여서 정리하지는 않겠다

프로세스

너무 많이 했다.

프로세스 : 실행중인 프로그램

이제 OS가 프로세스를 관리해주야 하는데 어떻게 관리할것인가? 가 관건이다

이를 이해하기 위해 프로세스의 생명주기를 이해해야 한다

프로세스 생명주기

- NEW

프로세스가 생성된 상태

- RUNNING

프로세스가 CPU를 점유해서 해당 명령어를 CPU가 처리하고 있는 상태

- WAITING

CPU가 다른 처리를 하고 있어서 기다리고 있는 상태

EX) 프로세스1이 running 상태일때 프로세스2가 기다리고 있는 상황

EX2) IO를 일으켜서 점유를 반납하는 상황

- READY

레디큐에서 CPU 점유를 대기하고 있는 상황

EX) IO를 일으키고 waiting도 끝난 다음 대기

- TERMINATED

모두 처리된 상태

PCB (process control block)

TCB라고 부르기도 한다고 한다 (task control block)

생명주기 알았고

이제 이 생명주기들을 가지는 프로세스를 정말 어떻게 관리할 것인가?가 PCB이다

-> 프로세스가 가져야할 정보를 모두 하나의 구조체에 저장하자는 아이디어가 PCB

우선 PCB는 메모리에 존재하는 자료구조이고

다음과 같은 정보들을 저장한다

- process state : 상태 (new, running 등)

- program counter : 다음으로 실행할 명령어의 메모리 주소 저장하는 레지스터 (CPU에 있겠지?)

컨텍스트 스위칭이 일어나고 다시 실행할때 다음 실행할 주소를 기억해야 하니까

- CPU 레지스터

- CPU 스케줄링 정보

- 메모리 정보

- 열린 파일 정보

등

--> 내용들을 생각해보면 PCB는 프로세스마다 하나씩 있겠구나를 생각해볼 수 있다

스레드

또 복습이긴 하다

프로세스 내부에서도 여러가지 작업을 처리학 위해 존재하는

실행하는 작업의 단위.

스레드는 나중에 다시 나온다고 한다

멀티 프로그래밍

다시 처음으로 돌아와서

멀티 프로그래밍의 목적은

동시에 여러개의 프로세스를 실행시키기 위함이다.

그래서 조합해보면 JVM 공부할때 했던 병렬 처리는 하나의 java 프로세스 안에서 스레드 여러개를 처리하는거고

지금 하고 있는 OS를 공부할때는 컴퓨터 전체 자원 관점에서 여러개의 프로세스를 동시에 실행시키는

즉 스포티파이를 키고, 브라우저를 실행하면서 워드 프로그램을 띄우는 느낌

-> 1. at the same time, simultaneously, concurrently는 동일한 의미

2. parallel (병렬적)은 약간 다른 의미

1번 concurrently는 동시성으로 정확히 번갈아가면서 실행하는거다

근데 그게 엄청 빠르니까 동시처럼 보이는 것 - time sharing과 관련된 내용

2번 parallel은 병렬성으로 진짜 물리적으로 동시에 실행하는거다

이를 달성하기 위해 사용하는 기법이 스케줄링이고 많이 나왔던게 time sharing, 그중에서도 라운드 로빈 등등..

이 스케줄링을 위해 프로세스들을 관리하는 것이 ready queue

IO를 발생시키고는 waiting 상태로 들어간다고 했다

이때는 wait queue로 들어가게 될텐데

당연히 이 경우에는 큐 개수가 여러개일 것

(각 디바이스마다, 즉 인터럽트를 기다리는 대상이 다르기 때문)

다시 작성하는데, 헷갈리면 안되는게 waiting queue에서 인터럽트 받고 바로 running이 아니라 ready queue로 간다!!

context switch

context?

프로세스의 문맥

OS 입장에서는 PCB 정보가 프로세스의 context가 되겠다

interrupt 상황을 보면

현재 running중인 프로세스의 context를 저장하고 (EX) PC)

커널 모드로 들어가 다른 작업을 수행하거나 ready queue에 있는 다음 프로세스를 수행

프로세스 생성

fork()라는 system call 명령어를 사용한다면

현재 프로세스를 복제해서 자식 프로세스를 만드는 작업이다

아래쪽이 자식

위쪽이 부모 프로세스

이런 과정을 거친다고 하는데 사실 잘 이해가 안간다

예시로 살펴보면

OS 입장에서는 새로운 프로그램을 위해 새로운 프로세스를 생성하는게 복잡하니까

fork()로 복제본을 생성하고, exec()로 새로운 프로그램으로 변환, 실행 후 자식 종료

그리고 그동안 부모 프로세스는 wait

이때 부모 프로세스가 wait 하지 않고 종료해버리면

자식 프로세스는 고아 프로세스가 되고, 그 상태로 계속 남아있다면 zombie process

여기서 address space도 복제한다고 하는데,

이건 아직 설명이 없다

아마 가상메모리와 관련된 내용은 뒤에서 나올 것 같다

process들은 기본적으로 독립적이다

하지만 cooperating 즉 데이터를 공유하거나 주고받을 때 문제가 생기는데

이걸 IPC라고 한다

Inter-process communication

이걸 해결하기 위해

- shared memory

- message passing

두가지 방법을 사용할 수 있다

a가 shared memory

b가 message passing을 나타낸 그림이다

생산자 - 소비자 문제

항상 나오는 문제인데

문제되는 지점은

버퍼가 가득 찼을 때 생산자가 또 넣으려고 하면?
버퍼가 비었을 때 소비자가 꺼내려고 하면?
동시에 접근하면 데이터 꼬임

이를 해결하기 위해 a 방법이 buffer 버퍼를 shared memory로 사용하면 된다는거다

producer는 버퍼가 가득 찼을 때 버퍼에 데이터를 채우는걸 멈추고 기다리면 되고

consumer는 버퍼가 비었을 때 버퍼에서 데이터를 가져오는걸 멈추고 기다리면 된다

이 버퍼를 공유 메모리로 사용하면 될 것

(이때 동작은 time sharing 즉 concurrently 개념으로 생각하면 된다)

shared memory 방식의 문제점도 존재한다

-> 프로그램을 짜는 사람이 자체적으로 이를 해결해야한다는 문제점

이래서 나오는게 message passing 방식인데

OS 자체적으로 shared memory를 관리하고 이때 발생하는 동기화 문제를 관리하는

즉 message passing을 위한 api를 제공해 주는 개념이다

send(message)

receive(message)

이렇게 나오는 내용이 여기에 속한다

이때 message passing을 할때도

- 생산자 소비자가 직접적으로 커뮤니케이트 할것인지

- 동기적으로 / 비동기적으로 커뮤니케이트 할것인지에 대한 내용이 나온다

이걸 전문적으로 표현하면

메일박스 (port)를 사용한

- direct / indirect 방식

동기적 / 비동기적인

- blocking IO / non-blocking io

이를 표준화한 것이

Shared memory는 POSIX

Message Passing에서는 Pipes

[JAVA] 알고리즘 고득점 kit dfs/bfs

grammiboii — Tue, 11 Nov 2025 17:17:35 +0900

타겟 넘버

가장 기본적인 dfs bfs

기본 dfs

import java.util.*;

class Solution {
    
    int answer = 0;
    
    public int solution(int[] numbers, int target) {
        
        dfs(numbers, target, 0, 0);
        
        return answer;
    }
    
    private void dfs(int[]numbers, int target, int index, int sum){
        
        if(index == numbers.length){
            
            if(target == sum){
                answer++;
            }
            
            return;
        }
             
        dfs(numbers, target, index+1, sum + numbers[index]);
        dfs(numbers, target, index+1, sum - numbers[index]);
        
    }
    
    
}

dfs를 클래스 변수 안쓰고

import java.util.*;

class Solution {
    public int solution(int[] numbers, int target) {
        return dfs(numbers, target, 0, 0);
    }
    
    private int dfs(int[] numbers, int target, int index, int sum) {
        if(numbers.length == index){
            if(target == sum){
                return 1;
            }
            return 0;
        }
        
        return dfs(numbers, target, index + 1, sum + numbers[index]) + 
            dfs(numbers, target, index + 1, sum - numbers[index]);
    }
    
}

파이썬때 그대로 풀었는데 이렇게 풀면 메모이제이션이 가능하다는 장점이 있다

dfs 파람에 따라 리턴 값이 정해져 있기 때문

여기서는 index, sum이 같은 경우라면 return 값이 같을 것이다

이럴땐 클래스 변수로 hashmap 선언해서 key, value로 저장해놓기

게임맵 최단거리

기본 그래프 bfs

import java.util.*;

class Solution {
    public int solution(int[][] maps) {
        int[] dx = {1, -1, 0, 0};
        int[] dy = {0, 0, 1, -1};
        
        int answer = 0;
        
        int n = maps.length;
        int m = maps[0].length;
        
        Queue<int[]> q = new ArrayDeque<>();
        boolean [][] visited = new boolean[n][m];
        
        q.add(new int[] {0, 0, 1});
        visited[0][0] = true;
        
        
        while(!q.isEmpty()) {
            int[] polled = q.poll();
            int x = polled[0];
            int y = polled[1];
            int move = polled[2];
            
            if(x==n-1 && y==m-1) {
                return move;
            }
            
            for(int i=0; i<4; i++) {
                int nx = x + dx[i];
                int ny = y + dy[i];
                
                if(0 <= nx && nx < n && 0<= ny && ny < m) {
                    if(maps[nx][ny] == 1 && visited[nx][ny] == false ) {
                        q.add(new int[] {nx, ny, move+1});
                        visited[nx][ny] = true;
                    }
                }
                
            }
            
            
        }
        
        return -1;
    }
}

[JAVA] 알고리즘 고득점 kit 스택 / 큐 + 정렬

grammiboii — Thu, 6 Nov 2025 22:59:04 +0900

또 오랜만에 자바다

정렬

문제 들어가기 전에 자바 정렬 정리

// 배열 오름차순
Arrays.sort(arr);

// 배열 내림차순 (객체만)
Arrays.sort(arr, Collections.reverseOrder());

// 배열 커스텀 정렬
Arrays.sort(arr, (a, b) -> a - b);

// 두개 key로
Arrays.sort(arr, (a, b) -> {
		if (a[0] == b[0]) return a[1]-b[1]
        return a[0] - b[0]
	}
);


// 리스트 오름차순
Collections.sort(list);
list.sort(Comparator.naturalOrder());

// 리스트 내림차순
Collections.sort(list, Collections.reverseOrder());
list.sort(Comparator.reverseOrder());

// 2차원 배열
Arrays.sort(arr, (a, b) -> a[0] - b[0]);

// 문자열 길이순
Arrays.sort(arr, (a, b) -> a.length() - b.length());

K번째 수

https://school.programmers.co.kr/learn/courses/30/lessons/42748?language=java

간단한 정렬 문제 + substring

기억할 포인트

- 배열 자르기는 Arrays.copyOfRange(arr, i, j)

-> i부터 j-1까지 복사

- 정렬 Arrays.sort(arr);

import java.util.*;

class Solution {
    public int[] solution(int[] array, int[][] commands) {
        int[] answer = new int[commands.length];
        
        
        for(int idx=0; idx<commands.length; idx++){
            int i = commands[idx][0];
            int j = commands[idx][1];
            int k = commands[idx][2];
            
            int[] copy = Arrays.copyOfRange(array, i-1, j);
            Arrays.sort(copy);
            answer[idx] = copy[k-1];
        }
        
        
        return answer;
    }
}

가장 큰 수

https://school.programmers.co.kr/learn/courses/30/lessons/42746?language=java

붙이면 더 큰수를 찾는문제

문자열로 더했을 때 뭐가 더 큰지 비교하면 된다

기억할 포인트

- int 배열을 String 배열로 바꿔주는 부분

String.valueOf(num);

- 문자열로 비교할때 Comparator 사용하는 부분

Arrays.sort(arr, (a, b) -> (b+a).compareTo(a+b));

import java.util.*;

class Solution {
    public String solution(int[] numbers) {
        String answer = "";
        
        String[] arr = new String[numbers.length];
        for(int i=0; i<numbers.length; i++){
            arr[i] = String.valueOf(numbers[i]);
        }
        
        
        Arrays.sort(arr, (a,b) -> (b+a).compareTo(a+b));
        
        
        if(arr[0].equals("0")) return "0";

        
        StringBuilder sb = new StringBuilder();
        for(String el : arr) {
            sb.append(el);
        }
        
        
        return sb.toString();
    }
}

스택 큐

같은 숫자는 싫어

https://school.programmers.co.kr/learn/courses/30/lessons/12906

기억할 포인트

- list -> array

answer.stream().mapToInt(Integer::toIntValue).toArray();

기억 안나면 배열 생성하고 하나씩 넣어주기

int[] arrayAnswer = new int[answer.size()];

for문 돌면서 arrayAnswer[i] = answer.get(i);

import java.util.*;

public class Solution {
    public int[] solution(int []arr) {
        ArrayList<Integer> answer = new ArrayList<>();
        
        Integer prev = null;
        for(int el : arr) {
            if(prev == null) {
                answer.add(el);
                prev = el;
            }
            
            if (prev != null) {
                if(prev != el){
                    answer.add(el);
                }
                prev = el;
            }
        }
        // return answer.stream().mapToInt(Integer::intValue).toArray();
        
        int[] returnAnswer = new int[answer.size()];
        for (int i=0; i<answer.size(); i++){
            returnAnswer[i] = answer.get(i);
        }
            
            
        return returnAnswer;
    }
    
    public void print(Object o){
        System.out.println(o);
    }
}

기능개발

https://school.programmers.co.kr/learn/courses/30/lessons/42586

큐로도 할 수 있을 것 같은데 인덱스로 했다

import java.util.*;

class Solution {
    public int[] solution(int[] progresses, int[] speeds) {
        
        List<Integer> answer = new ArrayList<>();
        
        int date = 1;
        int complete = 0;
        
        for(int i=0; i<progresses.length; i++){
            int progress = progresses[i];
            int speed = speeds[i];
            
            int finishDate = dayLeft(progress, speed);
            
            // 남았을때 이전꺼 기록, 초기화, date 움직이기
            if(finishDate > date){
                
                if(complete != 0){
                    answer.add(complete);
                    complete = 0;
                }
                
                date = finishDate;
                complete++;
                
                continue;
            }
            // 이미 처리 완료이면 date 그대로 complete++
            complete++;
        }
        if(complete != 0){
            answer.add(complete);
        }
        
        
        return answer.stream().mapToInt(Integer::intValue).toArray();
    }
    
    public int dayLeft(int progress, int speed){
        int result = (100 - progress) / speed;
        int left = (100 - progress) % speed;
        if (left > 0){
            result++;
        }
        return result;
    }
    
}

프로세스

https://school.programmers.co.kr/learn/courses/30/lessons/42587

os 프로세스 우선순위 실행을 구현해보는 문제

기억할 포인트

- 큐2개를 쓰는 방법이 처음에 잘 생각이 안났다

지금보니 우선순위큐에는 인덱스를 저장할 필요는 없는 것 같다

pq에 배열을 안넣고 Integer를 넣어주면

Collections.reverseOrder()로 Comparator를 넣어줄 수 있어서 더 간결하다

- 우선순위큐는 pq.peek()하면서 꺼내지 않기

import java.util.*;


class Solution {
    public int solution(int[] priorities, int location) {
        int answer = 0;
        
        Queue<int[]> q = new ArrayDeque<>();
        Queue<int[]> pq = new PriorityQueue<>((a,b) -> b[1] - a[1]);
        
        for(int i=0; i<priorities.length; i++){
            q.add(new int[] {i, priorities[i]});
            pq.add(new int[] {i, priorities[i]});
        }
        
        while (! q.isEmpty()){
            int[] current = q.poll();
            
            if(current[1] < pq.peek()[1]){
                q.add(current);
            } else{
                pq.poll();
                // 실행
                answer++;
                if (current[0] == location) return answer;
            }
            
        }
        
        return answer;
    }
    
    public void print(Object o){
        System.out.println(o);
    }
    
}

[PYTHON] 프로그래머스 고득점 kit

grammiboii — Fri, 24 Oct 2025 21:29:39 +0900

정렬

k 번째 큰 수

https://school.programmers.co.kr/learn/courses/30/lessons/42748

쉬운문제

기억할 포인트

- 파이썬에서는 substring 사용할때 슬라이싱 array[i:j]

-> i 인덱스부터 j-1까지

문제에서는 인덱스+1 되어 있어서 i-1 : j

def solution(array, commands):
    answer = []
    for i, j, k in commands:
        
        substring = array[i-1:j]
        substring.sort()
        answer.append(substring[k-1])
    return answer

가장 큰 수

https://school.programmers.co.kr/learn/courses/30/lessons/42746

쉬운 정렬 문제

기억할 포인트

sort에서 key를 사용할때 자바처럼 매개변수 2개가 안들어간다

사용하려면

- from functools import cmp_to_key

from functools import cmp_to_key

def solution(numbers):
    
    def comparator(x, y):
        if x + y > y + x:
            return -1
        elif x + y < y + x:
            return 1
        else:
            return 0
        

        
    numbers = list(map(str, numbers))
    numbers.sort(key = cmp_to_key(comparator))
    
    answer =  ''.join(numbers)
    return '0' if answer[0] == '0' else answer

마지막에 0000 인 경우를 위해 예외처리해야하는 함정이 있었다

H-index

https://school.programmers.co.kr/learn/courses/30/lessons/42747

생각해내기가 어렵다.,, 시험시간에 이런 생각을 할 수 있을까?

def solution(citations):
    
    citations.sort(reverse=True)
    h = 0
    
    for i, citation in enumerate(citations):
        if citation >= i+1:
            h = i+1
        else:
            break
    return h

DFS / BFS

타겟 넘버

https://school.programmers.co.kr/learn/courses/30/lessons/43165?language=python3

기억할 포인트

from functools import lru_cache

메모이제이션 캐싱 풀이

dfs 풀이

def solution(numbers, target):
    answer = 0
    
    def dfs(index, current_sum):
        nonlocal answer
        
        if len(numbers) == index:
            if current_sum == target:
                answer += 1
            return
        
        dfs(index+1, current_sum + numbers[index])
        dfs(index+1, current_sum - numbers[index])
    
    dfs(0,0)
    
    return answer

count를 반환하는 dfs 풀이

def solution(numbers, target):
    
    def dfs(index, currnet_sum):
        
        if index == len(numbers):
            if currnet_sum == target:
                return 1
            return 0
        
        count = 0
        
        count += dfs(index+1, currnet_sum + numbers[index])
        count += dfs(index+1, currnet_sum - numbers[index])
        
        return count
    
    return dfs(0, 0)

bfs 풀이

from collections import deque

def solution(numbers, target):
    answer = 0
    
    q = deque([(0,0)])
    
    while q:
        index, current_sum = q.popleft()
        
        if index == len(numbers):
            if current_sum == target:
                answer += 1
            continue
        
        q.append((index + 1, current_sum + numbers[index]))
        q.append((index + 1, current_sum - numbers[index]))
    
    return answer

lru cache 적용 풀이

대신 캐싱을 적용하기 때문에 중간 로직에 answer+=1 하는 로직은 사용하면 안되고

dfs return 값으로 계산하는 방식을 사용해야한다

from functools import lru_cache

def solution(numbers, target):
    
    @lru_cache(maxsize = None)
    def dfs(index, current_sum):
        if len(numbers) == index:
            if target == current_sum:
                return 1
            return 0
        
        count = 0
        
        count += dfs(index + 1, current_sum + numbers[index])
        count += dfs(index + 1, current_sum - numbers[index])
        
        return count
    
    
    return dfs(0, 0)

네트워크

https://school.programmers.co.kr/learn/courses/30/lessons/43162

기본적인 섬찾기 문제

visited를 배열로 많이 하는데 여기서는 set으로 해봤다

from collections import defaultdict

def solution(n, computers):
    answer = 0
    dict = defaultdict(list)
    for i, computer in enumerate(computers):
          for j, c in enumerate(computer):
                if i != j and c == 1:                    
                    dict[i].append(j)
        
    visited = set()
    
    def dfs(index):
        nonlocal answer
        
        visited.add(index)
        for next in dict[index]:
            if next not in visited:
                dfs(next)
    
    for i in range(n):
        if i not in visited:
            answer += 1
            dfs(i)
    
    return answer

게임맵 최단거리

https://school.programmers.co.kr/learn/courses/30/lessons/1844?language=python3

오랜만에 파이썬으로 하니 굉장히 쉽다

기본적인 BFS

from collections import deque

def solution(maps):
    answer = 0
    n, m = len(maps), len(maps[0])
    
    q = deque([(0, 0, 1)])
    directions = [(0, 1), (0, -1), (1, 0), (-1, 0)]
    
    visited = [[False]*m for _ in range (n)]
    visited[0][0] = True
    
    while q:
        x, y, move = q.popleft()
        
        if x == n-1 and y == m-1:
            return move
        
        for dx, dy in directions:
            xx, yy = x + dx, y + dy
            if 0 <= xx < n and 0 <= yy < m and maps[xx][yy] == 1 and visited[xx][yy] == False:
                visited[xx][yy] = True
                q.append((xx, yy, move+1))
        
    return -1

단어 변환

BFS

기억할 포인트

- zip

처음 풀이 - 오답

can transform 메서드가 틀렸다

(위치를 생각하지 않아서)

from collections import deque

def solution(begin, target, words):
    
    # a에서 b로
    def can_transform(a, b):
        return len(set(a) - set(b)) == 1
    
        
    if target not in words:
        return 0
    
    q = deque([(begin, 0)])
    visited = set([begin])
    
    while q:
        current, count = q.popleft()
        
        if current == target:
            return count
        
        for word in words:
            if word not in visited and can_transform(current, word):
                visited.add(word)
                q.append((word, count + 1))
        
    return 0

수정

zip을 사용했는데 그냥 index로 계산해도 된다

from collections import deque

def solution(begin, target, words):
    
    # a에서 b로
    def can_transform(a, b):
        diff_count = 0
        for c1, c2 in zip(a, b):
            if c1 != c2:
                diff_count += 1
        return diff_count == 1
    
        
    if target not in words:
        return 0
    
    q = deque([(begin, 0)])
    visited = set([begin])
    
    while q:
        current, count = q.popleft()
        
        if current == target:
            return count
        
        for word in words:
            if word not in visited and can_transform(current, word):
                visited.add(word)
                q.append((word, count + 1))
        
    return 0

zip을 살펴보면 리스트 두개 OR 문자열 두개를 나란히 묶어주는 메서드

둘의 길이가 다르면 짧은 쪽에 맞춰진다

응용해서 파이썬식 좀더 간결하게

    def can_transform(a, b):
        return sum(c1 != c2 for c1, c2 in zip(a, b)) == 1

이렇게 사용할 수 있다.

시험시간에 기억 안나면 그냥 인덱스로 빨리 풀자

여행경로

어렵다

핵심 아이디어는 막다른 길까지 도달해야한다는 점이다

[["ICN", "JFK"], ["HND", "IAD"], ["JFK", "HND"]]

ticket일때

icn -> jfk

재귀

current jfk

jfk -> hnd

재귀

current hnd

hnd -> iad

재귀

current iad

여기서 딕셔너리가 비어있기 때문에 while문으로 들어가지 않는다

그러면 current인 aid를 answer에 append

탈출

hnd를 append

jfk append

icn append

리스트를 뒤집으면 경로가 나온다

import heapq
from collections import defaultdict

def solution(tickets):

    dict = defaultdict(list)
    
    for f, t in tickets:
        heapq.heappush(dict[f], t)
    
    answer = []
    
    def dfs(current):
        while dict[current]:
            next = heapq.heappop(dict[current])
            dfs(next)
        
        answer.append(current)
        

    dfs("ICN")
    return answer[::-1]

[JVM 밑바닥까지 파헤치기] 2장 자바 메모리 영역과 오버플로우

grammiboii — Fri, 15 Aug 2025 17:51:52 +0900

자바 스레드, 동시성 강의와 책을 병행하려고 한다.

런타임 데이터 영역

https://gothax.tistory.com/48

강의에서 본 자바 메모리 영역을 이렇게 봤었다.

책을 읽어보니 조금 더 자세하게 나와있었다.

프로그램 카운터 (Program Counter Registry)

이부분이 위 그림에 안나와 있었다 편의상 생략된듯

pc register는 작은 메모리 영역으로

현재 실행중인 스레드의 바이트코드 줄 번호 표시기라고 할 수 있다.

스택 영역에서 메서드를 실행할때마다 스택 프레임을 쌓고, 코드를 한줄한줄 실행한다고 했던거 기억이 나는가?

여기서 그 한줄한줄 실행할때 어디인지를 기록하는 것

좀더 이론적으로

바이트코드 인터프리터가 이 카운터의 값을 바꿔 다음 실행할 명령어를 선택하는 식으로 작동한다.

이를 이용해 프로그램의 제어 흐름, 분기, 순환, 점프 등을 표현한다.

예외처리, 스레드 복원같은 기본 기능이 이 표시기를 사용한다.

당연히 스레드별로 분리되어 있다. (스레드 프라이빗 메모리)

유일하게 OOM out of memory 예외 조건이 명시되지 않은 영역이라고 한다.

스택 영역 (Stack)

복습할겸 다시 적어보면

스레드 별 하나의 실행 스택이 생성되고 (스레드 수 만큼 스택이 생성된다)

자바 메서드를 실행하는 스레드의 메모리 모델을 설명해준다.

각 메서드가 호출될 때마다 가상머신이

스택 프레임을 생성해 지역변수 테이블, 피연산자 스택, 동적 링크, 메서드 반환값등의 정보를 저장한다.

그리고 이 스택프레임을 스택 영역에 push, pop을 반복

지역 변수 테이블에는 컴파일 타임에 알 수 있는

데이터 타입, 객체 참조, 반환 주소 타입을 저장한다.

이 값들을 저장하는 공간들을 지역 변수 슬롯이라고 한다. (일반적으로 32bit)

이는 컴파일 과정에서 할당되고 메서드 실행중에 절대 변하지 않는다. (슬롯 개수)

<<자바 가상 머신 명세>>에서

스택 메모리 영역에서는 두가지 예외를 던질 수 있도록 정의했다

1. StackOverFlow

요청한 스택 깊이가 가상머신이 허용하는 깊이보다 깊을때

2. OOM

~~현재의 핫스팟 가상 머신은 스택 용량을 동적으로 늘리지 못하기 때문에 던질 일이 없다고 한다~~

~~이거 뭔말인지 모르겠다~~

마찬가지로 스레드별로 분리되어 있다. (스레드 프라이빗 메모리)

힙 영역 (Heap)

객체 인스턴스를 저장한다.

모든 인스턴스와 배열을 생성하는데

책에는 "거의" 모든이라고 나와 있다. 구현 관점에서 자바가 발전하며 스택 할당과 스칼라 치환 최적화 방식이 살짝 달라져서라고 하는데, 뭔말인지 잘 모르겠다. 일단 모든 인스턴스라고 이해하고 넘어가자.

GC가 관리하는 메모리 영역이어서 GC 힙이라고도 부른다.

객체 할당 효율을 높이고자 스레드 로컬 할당 버퍼 여러개로 나뉜다고 한다. 즉 메모리 회수와 할당을 더 빠르게 하기 위함이라고 하는데 이건 뒤에 나오는 것 같다.

자바 힙은 크기를 고정할수도, 확장할수도 있게 구현할 수 있다. 주류로 사용되는 가상 머신은 대부분 확장 가능한 형태라고 한다.

이로 인해 새로운 인스턴스를 위한 힙 영역이 부족하고, 힙을 확장할 수 없을때

OOM 예외를 던진다.

인스턴스를 참조해야하니까 힙 영역은

모든 스레드가 공유한다.

메서드 영역 (Method)

가상 머신이 읽은

타입정보, 상수, static 변수, 코드 캐시등을 저장한다.

다른 강의에서 봤던 그림에는

클래스 정보, static 변수, 상수풀을 저장한다고 되어 있는데

타입 정보 + 코드 캐시 -> 클래스 정보

static 변수

상수

이렇게 생각하면 될 것 같다.

코드 캐시를 좀더 자세하게

JIT 컴파일러가 컴파일한 코드라고 이해하면 된다고 한다.

힙과 마찬가지로

모든 스레드가 공유한다.

[JAVA 고급1] 3. 스레드 제어와 생명주기 1

grammiboii — Wed, 13 Aug 2025 01:07:01 +0900

스레드 생명 주기

OS에서도 많이 본 그림인데 하나씩 살펴보면

- New

스레드가 생성되었지만 시작되지 않은 상태

start 메서드를 호출하지 않은 상태이다.

- Runnable

스레드가 실행중이거나 실행될 준비가 된 상태

start 메서드를 호출하면 해당 상태로 들어간다

OS 스케줄러가 각 스레드에 CPU 시간을 할당해 실행하기 때문에 (time waiting)

Runnable 상태 스레드는 실행 대기열에 포함되었다가 차례로 CPU에서 실행된다. - 자바에서는 이를 구분할 수 없다

- 일시 중지 상태들

- Blocked : 스레드가 락을 기다리는 상태 (뒤에서 synchronized와 모니터 락을 배운다)

- Waiting : 스레드가 무기한으로 다른 스레드의 작업을 기다리는 상태 (wait, join, notify, notifyAll)

- Timed Waiting : 스레드가 일정 기간동안 다른 스레드의 작업을 기다리는 상태 (sleep(ms), wait(ms), join(ms))

- Terminated

스레드의 실행이 완료된 상태

join 시작

main 스레드는

thread1, thread2에게 Job을 시키고 자신의 코드를 실행한다.

하지만

thread1, thread2가 종료되고 main 스레드를 종료하려면 어떻게 해야할까? -> 이때 join이 필요하다.

이런 상황은 예를 들어

thread1, thread2에 어떤 작업을 지시하고 이 결과값을 main 스레드에서 받아 사용할때 필요하다

join이 필요한 상황 예제

예를 들어

1~100까지 숫자를 더하는 작업을 수행하는데 이걸 병렬로 돌리기 위해

1~50을 더하는 작업을 thread-1에게 시키고

51~100까지 더하는 작업을 thread-2에게 시킨다고 하자

그리고 확실히 결과를 보기 위해 thread-1, thread-2에서 수행하는 작업이 2초 걸린다고 가정하자

이때 결과는 어떻게 나올까?

main 스레드가 thread-1, thread-2의 작업을 기다리지 않기 때문에

결과값이어야 하는 5050이 나오지 않고 0이라는 결과가 나온다.

[JAVA 고급1] 2. 스레드의 생성과 실행

grammiboii — Mon, 11 Aug 2025 00:34:50 +0900

Java 메모리 구조

Java 메모리는 3가지 영역으로 구성되어 있다

- 메서드 영역 Method Area

프로그램을 실행하는데 필요한 공통 데이터를 관리한다

그러므로 프로그램의 모든 영역에서 공유

안에 있는 3가지는 각각

클래스 정보 : 클래스 실행 코드, 필드, 메서드, 생성자등 모든 실행코드

static 영역 : static 변수 보관

런타임 상수 풀 : 공통 리터럴 상수

- 스택 영역 Stack Area

스레드 별 하나의 실행 스택이 생성된다 (스레드 수 만큼 스택이 생성된다)

네모칸 하나가 스택 프레임이고

지역 변수, 중간 연산 결과, 메서드 호출 정보를 포함한다

메서드를 호출할 때 마다 하나의 스택 프레임이 쌓이고, 메서드가 종료되면 해당 스택 프레임이 제거된다.

- 힙 영역 Heap Area

객체(인스턴스), 배열이 생성되는 영역

GC가 이루어지는 주요 영역

더이상 참조되지 않는 객체는 GC에 의해 제거됨

스레드 생성

스레드를 직접 만들때

Thread 클래스를 상속받는 법, Runnable 인터페이스를 구현하는 방법이 있다.

Thread 상속

상속하고 run 메서드를 override해주면 된다

주의할 점은 오버라이드한 run 메서드를 호출하는 것이 아니라

start 메서드를 실행해야한다

- 이유는 뒤에서

실행할때마다

우리가 만든 스레드 내부에서 실행되는 Thread-0 출력 순서가 달라질 수 있다

- 이 이유도 뒤에서

해석해보면

프로세스가 실행되기 위해 최소 하나의 스레드가 필요하니

main 스레드가 시작되고

main 스택 영역이 할당된다

그후 HelloThread 인스턴스를 생성한다

그후 start() 메서드를 호출할때

자바가 스레드를 위한 스택 영역을 할당한다

그러면서 Thread-0 스레드가 run() 메서드의 스택 프레임을 스택에 올리고 run()메서드를 시작한다

더 자세히 보면

주의할 점은

run() 메서드를 실행하는 것은 Thread-0 라는 점

main 스레드는

start()메서드로 Thread-0 스레드에게 시작하라고 명령을 하고

그 후 일을 진행하는 것이다.

--> 이러면 Thread-0에서 실행되는 출력 순서가 달라지는 이유가 이해된다.

main 스레드 입장에서는 start로 Thread-0를 부르고 이후, 기다리지 않고 start 메서드를 빠져 나와 출력을 찍은 것이고

동시에 Thread-0 내부에서는 출력을 수행하니 순서가 달라질 수 있는 것

즉 main 스레드와 Thread-0가 동시에 실행되는 것

--> 그리고 이로 인해 main 스레드에서 Thread-0 run 메서드가 아닌 start 메서드를 호출해야하는 이유도 이해가 된다.

run을 호출하게 되면 Thread-0에서 run 메서드를 실행하는게 아니라

main 스레드에서 run 메서드를 실행하게 되는 것

즉, 스택 영역이 하나만 할당되는 것이다.

코드를 보면

그림으로 보면

사용자 스레드, 데몬 스레드 (user thread, daemon thread)

스레드는 두가지 종류가 있다

- 사용자 스레드 (non-daemon thread)

프로그램 주요 작업을 수행

작업이 완료 될때까지 실행된다

모든 user thread가 종료되면 JVM이 종료된다

- 데몬 스레드 (daemon thread)

백그라운드 작업을 실행

모든 user thread가 종료되면 daemon thread는 자동으로 종료된다

예를 들어 사용하지 않는 파일이나 메모리를 정리하는 작업을 수행

JVM이 종료되는 시점에 대해 추가하면

모든 사용자 스레드가 종료될 때까지 기다려야 하므로

모든 스택 영역이 빌때까지 기다리고

모두 비었다면 그때 종료된다

반면에 데몬 스레드가 돌아가고 있어도 사용자 스레드가 모두 종료된다면 JVM이 종료된다.

daemon thread 예시를 보면

데몬 스레드 내부에서 10초 후에 출력을 하도록 설정했는데

daemon thread 내부 run 메서드 출력이 나오지 않고 프로그램이 종료된다

Runnable 인터페이스 구현

앞에서는 Thread 클래스를 상속받아 스레드를 생성했는데

이번에는 Runnable 인터페이스를 구현해서 스레드를 생성해보자

실무에서는 보통 이 방법을 사용한다고 한다.

별로 다른점은 없고

Thread 객체를 바로 생성하는게 아니라

runnable 객체를 만들고 thread 객체 생성자 파라미터로 전달한다는게 좀 다르다

이 부분때문에 실무에서 주로 사용한다고 한다.

정리하면 두가지 이유로 Runnable 인터페이스 구현 방식을 사용하라고 한다.

1. 스레드와 실행할 작업을 명확히 분리할 수 있다

2. 인터페이스를 사용하는 것이 상속보다 더 유연하고 유지보수 하기 쉽다