์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | 2 | 3 | 4 | |||
5 | 6 | 7 | 8 | 9 | 10 | 11 |
12 | 13 | 14 | 15 | 16 | 17 | 18 |
19 | 20 | 21 | 22 | 23 | 24 | 25 |
26 | 27 | 28 | 29 | 30 | 31 |
- Spring Boot
- Codeup
- java
- ํด๋ฆฐ ์ฝ๋
- ๊ธฐ์ด100์
- ์ฝ๋์
- Gradle
- ์ค๋ธ์
- ํ์ด์ฌ
- Python
- GitHub
- thymeleaf
- JPA
- MySQL
- springboot
- Vue.js
- ๋กฌ๋ณต
- Spring
- ์๊ณ ๋ฆฌ์ฆ
- ์คํ๋ง
- ๊ฐ์ฌ์ค
- go
- Postman
- ํด๋ฆฐ์ฝ๋
- mariadb
- H2 ์ค์น
- spring security
- ํฐ์คํ ๋ฆฌ์ฑ๋ฆฐ์ง
- Git
- golang
- Today
- Total
nyximos.log
[Java] ๋ฉํฐ์ฐ๋ ๋ ํ๋ก๊ทธ๋๋ฐ ๋ณธ๋ฌธ
๐ฉ๐ ๋ชฉํ
์๋ฐ์ ๋ฉํฐ์ฐ๋ ๋ ํ๋ก๊ทธ๋๋ฐ์ ๋ํด ํ์ตํ์ธ์.
๐ฉ๐ป ํ์ตํ ๊ฒ
- Thread ํด๋์ค์ Runnable ์ธํฐํ์ด์ค
- ์ฐ๋ ๋์ ์ํ
- ์ฐ๋ ๋์ ์ฐ์ ์์
- Main ์ฐ๋ ๋
- ๋๊ธฐํ
- ๋ฐ๋๋ฝ
๋ฉํฐ ํ์คํน Multi-tasking
์ฌ๋ฌ ๊ฐ์ ์ ํ๋ฆฌ์ผ์ด์ ์ ๋์์ ์คํ ๐ ์ปดํจํฐ ์์คํ ์ ์ฑ๋ฅ์ ๋์.
๋ฉํฐ ์ฐ๋ ๋ฉ Multi-threading
ํ๋์ ์ ํ๋ฆฌ์ผ์ด์
์์์๋ ์ฌ๋ฌ๊ฐ์ง ์์
์ ๋์์ ํ๋ ๊ฒ
๋ฉํฐ ์ฐ๋ ๋ฉ์ ์ฅ์
- CPU์ ์ฌ์ฉ๋ฅ ์ ํฅ์์ํจ๋ค.
- ์์์ ๋ณด๋ค ํจ์จ์ ์ผ๋ก ์ฌ์ฉํ ์ ์๋ค.
- ์ฌ์ฉ์์ ๋ํ ์๋ต์ฑ์ด ํฅ์๋๋ค.
- ์์ ์ด ๋ถ๋ฆฌ๋์ด ์ฝ๋๊ฐ ๊ฐ๊ฒฐํด์ง๋ค.
๋ฉํฐ ์ฐ๋ ๋ฉ์ ๋จ์
- ๋๊ธฐํ synchronization
- ๊ต์ฐฉ์ํ deadlock : ๋ฌดํ ๋๊ธฐ
- ๊ธฐ์ starvation : ์ฐ์ ์์๊ฐ ๋ฎ์์ ์ํ๋ ์์์ ๊ณ์ ํ ๋น๋ฐ์ง ๋ชปํ๋ ์ํ
ํ๋ก์ธ์ค process
- ์คํ ์ค์ธ ํ๋ก๊ทธ๋จ
- ์์ + ์ฐ๋ ๋
- ๋ ์์ ์ผ๋ก ์คํ์ด ๊ฐ๋ฅํ ํ๊ฒฝ์ ๊ฐ์ง๋ค.
- ํ๋ก๊ทธ๋จ์ ์คํํ๋ฉด OS๋ก๋ถํฐ ํ์ํ ์์(๋ฉ๋ชจ๋ฆฌ)๋ฅผ ํ ๋น๋ฐ์ ํ๋ก์ธ์ค๊ฐ ๋๋ค.
- ๋ชจ๋ ํ๋ก์ธ์ค์๋ ์ต์ํ ํ๋ ์ด์์ ์ฐ๋ ๋๊ฐ ์กด์ฌํ๋ค.
- ๋ฉํฐ์ฐ๋ ๋ ํ๋ก์ธ์ค multi-threaded process : ๋ ์ด์์ ์ฐ๋ ๋๋ฅผ ๊ฐ์ง ํ๋ก์ธ์ค
์ฐ๋ ๋ thread
- ๊ฐ๊ฐ์ ์์
- ํ๋ก์ธ์ค ์์์ ์กด์ฌ
- ๋ฉ๋ชจ๋ฆฌ์ ํ์ผ์ ํฌํจํ์ฌ ํ๋ก์ธ์ค์ ๋ชจ๋ ์์์ ๊ณต์
- ๋ชจ๋ ์๋ฐ ์ ํ๋ฆฌ์ผ์ด์ ์ ์ ์ด๋ ํ๋์ thread๋ฅผ ๊ฐ์ง๊ณ ์๋ค.
- main thread๋ผ๊ณ ๋ถ๋ฅด๋ ํ๋์ ์ค๋ ๋๋ก ์ถ๋ฐํ๋ค.
Thread ํด๋์ค์ Runnable ์ธํฐํ์ด์ค
์ฐ๋ ๋ ์์ฑํ๋ ๋ฐฉ๋ฒ์ ๋๊ฐ์ง๊ฐ ์๋ค.
1. Thread ํด๋์ค ์์
Thread ํด๋์ค๋ฅผ ์์๋ฐ์ผ๋ฉด ๋ค๋ฅธ ํด๋์ค๋ฅผ ์์๋ฐ์ ์ ์๋ค.
1. Thread๋ฅผ ์์๋ฐ์ ํด๋์ค๋ฅผ ์์ฑํ๋ค.
2. run() ๋ฉ์๋๋ฅผ ์ฌ์ ์ํ๋ค.
3. Thread ๊ฐ์ฒด๋ฅผ ์์ฑํ๋ค.
4. start()๋ฅผ ํธ์ถํด์ ์ฐ๋ ๋๋ฅผ ์์ํ๋ค.
class MyThread extends Thread{
public void run() { /* ์์
๋ด์ฉ */ } // Thread ํด๋์ค์ run()์ ์ค๋ฒ๋ผ์ด๋ฉ
}
2. Runnable ์ธํฐํ์ด์ค ๊ตฌํ
๋ค๋ฅธ ํด๋์ค๋ฅผ ์์ ๋ฐ์ ์ ์๊ธฐ ๋๋ฌธ์ ๋ณดํต Runnable ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ๋ค.
์ฌ์ฌ์ฉ์ฑ์ด ๋๋ค.
์ฝ๋์ ์ผ๊ด์ฑ์ ์ ์งํ ์ ์๊ธฐ ๋๋ฌธ์ ๋ณด๋ค ๋ณด๋ค ๊ฐ์ฒด์งํฅ์ ์ธ ๋ฐฉ๋ฒ์ด๋ค.
1. Runnable ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ ํด๋์ค๋ฅผ ์์ฑํ๋ค.
2. run() ๋ฉ์๋๋ฅผ ์์ฑํ๋ค.
3. Thread ๊ฐ์ฒด๋ฅผ ์์ฑํ๊ณ ์ด๋ ์๊น ๊ตฌํํ ํด๋์ค ๊ฐ์ฒด๋ฅผ ์ธ์๋ก ์ ๋ฌํ๋ค.
4. start()๋ฅผ ํธ์ถํด์ ์ฐ๋ ๋๋ฅผ ์์ํ๋ค.
class MyThread implements Runnable {
public void run() { /* ์์
๋ด์ฉ */ } // Runnable ์ธํฐํ์ด์ค์ run() ๊ตฌํ
}
Runnable ์ธํฐํ์ด์ค
run() ๋ง ์ ์๋์ด ์๋ ๊ฐ๋จํ ์ธํฐํ์ด์ค๋ค.
public interface Runnable {
public abstract void run();
}
์ฐ๋ ๋ ๊ตฌํ & ์คํ
public class ThreadTest{
public static void main(String args[]){
InheritedThread thread1 = new InheritedThread();
InheritedThread thread2 = new InheritedThread();
Runnable r = new RunnableThread();
Thread thread3 = new Thread(r);
Thread thread4 = new Thread(r);
thread1.start();
thread2.start();
thread3.start();
thread4.start();
}
}
class InheritedThread extends Thread {
public void run() {
for(int i=0; i<5; i++){
System.out.println(getName());
}
}
}
class RunnableThread implements Runnable {
public void run() {
for(int i=0; i<5; i++){
System.out.println(Thread.currentThread().getName());
}
}
}
๋งค๋ฒ ๊ฒฐ๊ณผ๊ฐ ๋ค๋ฅด๋ค.
Thread-0
Thread-0
Thread-0
Thread-0
Thread-0
Thread-2
Thread-2
Thread-2
Thread-2
Thread-2
Thread-1
Thread-1
Thread-1
Thread-1
Thread-1
Thread-3
Thread-3
Thread-3
Thread-3
Thread-3
Process finished with exit code 0
start( )
์คํ๋๊ธฐ ์ํ์ ์๋ค๊ฐ ์์ ์ ์ฐจ๋ก๊ฐ ๋๋ฉด ์คํํ๋ค.
ํ๋์ ์ฐ๋ ๋์ ๋ํด start( )๊ฐ ํ ๋ฒ๋ง ํธ์ถ๋ ์ ์๋ค.
๋ ๋ฒ ์ด์ ํธ์ถ์ IllegalThreadStateException์ด ๋ฐ์ํ๋ค.
sleep(long millis)
์ง์ ๋ ์๊ฐ ๋์ ์ฐ๋ ๋๋ฅผ ์ผ์์ ์ง ์ํจ๋ค.
์ง์ ๋ ์๊ฐ์ด ์ง๋๊ณ ๋๋ฉด, ์๋์ ์ผ๋ก ๋ค์ ์คํ๋๊ธฐ๊ฐ ๋๋ค.
void join( )
์ง์ ๋ ์๊ฐ๋์ ์คํ๋๋๋ก ํ๋ค.
void interrupt( )
sleep( ) ์ด๋ join( ) ์ ์ํด ์ผ์์ ์ง ์ํ์ธ ์ฐ๋ ๋๋ฅผ ๊นจ์์ ์คํ ๋๊ธฐ ์ํ๋ก ๋ง๋ ๋ค.
static void yield( )
์คํ ์ค์ ์์ ์๊ฒ ์ฃผ์ด์ง ์คํ ์๊ฐ์ ๋ค๋ฅธ ์ฐ๋ ๋์๊ฒ ์๋ณดํ๊ณ ์์ ์ ์คํ๋๊ธฐ ์ํ๊ฐ ๋๋ค.
void stop()
์ฐ๋ ๋๋ฅผ ์ฆ์ ์ข ๋ฃ์ํจ๋ค.
deprecated
void suspend( )
์ฐ๋ ๋๋ฅผ ์ผ์์ ์ง ์ํจ๋ค.
resume( )์ ํธ์ถํ๋ฉด ๋ค์ ์คํ๋๊ธฐ ์ํ๊ฐ ๋๋ค.
deprecated
void resume( )
suspend( )์ ์ํด ์ผ์์ ์ง์ํ์ ์๋ ์ฐ๋ ๋๋ฅผ ์คํ๋๊ธฐ ์ํ๋ก ๋ง๋ ๋ค.
deprecated
์ฐ๋ ๋์ ์ํ
NEW
์ฐ๋ ๋๊ฐ ์์ฑ๋๊ณ ์์ง start()๊ฐ ํธ์ถ๋์ง ์์ ์ํ
RUNNABLE
์คํ ์ค์ด๊ฑฐ๋ ์คํ ๊ฐ๋ฅํ ์ํ
BLOCKED
๋๊ธฐํ ๋ธ๋ญ์ ์ํด์ ์ผ์์ ์ง๋ ์ํ
lock์ด ํ๋ฆด ๋๊น์ง ๊ธฐ๋ค๋ฆฌ๋ ์ํ
WAITING/TIMED_WAITING
์ฐ๋ ๋์ ์์ ์ด ์ข ๋ฃ๋์ง๋ ์์์ง๋ง
์คํ๊ฐ๋ฅํ์ง ์์ ์ผ์์ ์ง์ํ
TIMED_WAITING : ์ผ์์ ์ง ์๊ฐ์ด ์ง์ ๋ ๊ฒฝ์ฐ ์๋ฏธ
TERMINATED
์ฐ๋ ๋์ ์์ ์ด ์ข ๋ฃ๋ ์ํ
1. ์ฐ๋ ๋ ์์ฑํ๊ณ start( )๊ฐ ํธ์ถํ๋ฉด ๋ฐ๋ก ์คํ๋์ง ์๊ณ ,
์คํ ๋๊ธฐ์ด์ ์ ์ฅ๋์ด ์์ ์ ์ฐจ๋ก๊ฐ ๋ ๋๊น์ง ๊ธฐ๋ค๋ ค์ผ ํ๋ค.
์คํ๋๊ธฐ์ด์ ํ Queue ๊ฐ์ ๊ตฌ์กฐ๋ก ๋จผ์ ์คํ ๋๊ธฐ์ด์ ๋ค์ด์จ ์ฐ๋ ๋๊ฐ ๋จผ์ ์คํ๋๋ค.
2. ์คํ๋๊ธฐ์ํ์ ์๋ค๊ฐ ์์ ์ ์ฐจ๋ก๊ฐ ๋๋ฉด ์คํ ์ํ๊ฐ ๋๋ค.
3. ์ฃผ์ด์ง ์คํ์๊ฐ์ด ๋ค ๋๊ฑฐ๋ yeild( )๋ฅผ ๋ง๋๋ฉด ๋ค์ ์คํ๋๊ธฐ์ํ๊ฐ ๋๊ณ ,
๋ค์ ์ฐจ๋ก์ ์ฐ๋ ๋๊ฐ ์คํ ์ํ๊ฐ ๋๋ค.
4. ์คํ์ค์ suspend( ), sleep( ), wait( ), join( ), I/O block์ ์ํด ์ผ์์ ์ง ์ํ๊ฐ ๋ ์ ์๋ค.
I/O block์ ์ ์ถ๋ ฅ์์ ์์ ๋ฐ์ํ๋ ์ง์ฐ ์ํ๋ฅผ ๋งํ๋ค.
์ฌ์ฉ์์ ์ ๋ ฅ์ ๊ธฐ๋ค๋ฆฌ๋ ๊ฒฝ์ฐ๋ฅผ ์๋ก ๋ค์ ์๋ค. → ์ผ์์ ์ง ์ํ์ ์๋ค๊ฐ ์ฌ์ฉ์๊ฐ ์ ๋ ฅ์ ๋ง์น๋ฉด ๋ค์ ์คํ๋๊ธฐ ์ํ๊ฐ ๋๋ค.
5. ์ง์ ๋ ์ผ์์ ์ง์๊ฐ์ด ๋ค๋๊ฑฐ๋(time-out), notify( ), resume( ), interrupt( )๊ฐ ํธ์ถ๋๋ฉด,
์ผ์์ ์ง ์ํ๋ฅผ ๋ฒ์ด๋ ๋ค์ ์คํ๋๊ธฐ์ด์ ์ ์ฅ๋์ด ์์ ์ ์ฐจ๋ก๋ฅผ ๊ธฐ๋ค๋ฆฌ๊ฒ ๋๋ค.
6. ์คํ์ ๋ชจ๋ ๋ง์น๊ฑฐ๋ stop( )์ด ํธ์ถ๋๋ฉด ์ฐ๋ ๋๋ ์๋ฉธ๋๋ค.
์ฐ๋ ๋์ ์ฐ์ ์์
์ฐ๋ ๋๋ ์ฐ์ ์์ priority๋ผ๋ ์์ฑ์ ๊ฐ์ง๊ณ ์๋ค.
์ด ์ฐ์ ์์์ ๊ฐ์ ๋ฐ๋ผ ์ฐ๋ ๋๊ฐ ์ป๋ ์คํ์๊ฐ์ด ๋ฌ๋ผ์ง๋ค.
์ฐ๋ ๋๊ฐ ์ํํ๋ ์์ ์ ์ค์๋์ ๋ฐ๋ผ ์ฐ๋ ๋์ ์ฐ์ ์์๋ฅผ ์๋ก ๋ค๋ฅด๊ฒ ์ง์ ํ์ฌ,
ํน์ ์ฐ๋ ๋๊ฐ ๋ ๋ง์ ์์ ์๊ฐ์ ๊ฐ๋๋ก ํ ์ ์๋ค.
์ฐ๋ ๋ ์ฐ์ ์์ ์ง์ ํ๊ธฐ
- ์ฐ๋ ๋๊ฐ ๊ฐ์ง ์ ์๋ ์ฐ์ ์์์ ๋ฒ์๋ 1~10์ด๋ค.
- ์ซ์๊ฐ ๋์์๋ก ์ฐ์ ์์๊ฐ ๋๋ค.
- ์ฐ๋ ๋์ ์ฐ์ ์์๋ ์ฐ๋ ๋๋ฅผ ์์ฑํ ์ฐ๋ ๋๋ก๋ถํฐ ์์๋ฐ๋๋ค.
- main๋ฉ์๋๋ฅผ ์ํํ๋ ์ฐ๋ ๋๋ ์ฐ์ ์์๊ฐ 5์ด๋ฏ๋ก main() ๋ด์์ ์์ฑํ๋ ์ฐ๋ ๋์ ์ฐ์ ์์๋ ์๋์ ์ผ๋ก 5๊ฐ ๋๋ค.
public class MyThread implements Runnable {
void setPriority(int newPriority) // ์ฐ๋ ๋์ ์ฐ์ ์์๋ฅผ ์ง์ ํ ๊ฐ์ผ๋ก ๋ณ๊ฒฝ
int getPriority() // ์ฐ๋ ๋์ ์ฐ์ ์์๋ฅผ ๋ฐํ
public static final int MAX_PRIORITY = 10 // ์ต๋ ์ฐ์ ์์
public static final int MIN_PRIORITY = 1 // ์ต์ ์ฐ์ ์์
public static final int NORM_PRIORITY = 5 // ๋ณดํต ์ฐ์ ์์
}
Main ์ฐ๋ ๋
main( )์ ์์ ์ ์ํํ๋ ์ฐ๋ ๋
ํ๋ก๊ทธ๋จ์ด ์คํํ๋ฉด ๊ธฐ๋ณธ์ ์ผ๋ก ํ๋์ ์ฐ๋ ๋๋ฅผ ์์ฑํ๊ณ ๊ทธ ์ฐ๋ ๋๊ฐ main ๋ฉ์๋๋ฅผ ํธ์ถํ์ฌ ์์ ์ ์ํ๋๋๋ก ํ๋ค.
main ๋ฉ์๋๊ฐ ์ํ์ ๋ง์น๋ฉด ํ๋ก๊ทธ๋จ์ด ์ข ๋ฃ๋์ง๋ง
main ๋ฉ์๋๊ฐ ์ํ์ ๋ง์ณค๋ค ํ๋๋ผ๋ ๋ค๋ฅธ ์ฐ๋ ๋๊ฐ ์์ง ์์ ์ ๋ง์น์ง ์์ ์ํ๋ผ๋ฉด ํ๋ก๊ทธ๋จ์ด ์ข ๋ฃ๋์ง ์๋๋ค.
์คํ ์ค์ธ ์ฌ์ฉ์ ์ฐ๋ ๋๊ฐ ํ๋๋ ์์ ๋ ํ๋ก๊ทธ๋จ์ด ์ข ๋ฃ๋๋ค.
๋ฐ๋ชฌ ์ฐ๋ ๋
- ๋ฐ๋ชฌ ์ฐ๋ ๋๊ฐ ์๋ ์ผ๋ฐ ์ฐ๋ ๋์ ์์ ์ ๋๋ ๋ณด์กฐ์ ์ธ ์ญํ ์ ์ํํ๋ ์ฐ๋ ๋์ด๋ค.
- ๋ฐ๋ชฌ ์ฐ๋ ๋๋ ๊ฐ์ ์ ์ผ๋ก ์๋ ์ข ๋ฃ๋๋ค.
- ์ผ๋ฐ ์ฐ๋ ๋์ ๋ณด์กฐ ์ญํ ์ ์ํํ๋ฏ๋ก ์ผ๋ฐ ์ฐ๋ ๋๊ฐ ๋ชจ๋ ์ข ๋ฃ๋๋ฉด ๋ฐ๋ชฌ ์ฐ๋ ๋์ ์กด์ฌ๊ฐ ์๋ฏธ์๊ธฐ ๋๋ฌธ์ด๋ค.
- ์๋ก ๊ฐ๋น์ง ์ปฌ๋ ํฐ, ์๋ ํ๋ก์ธ์์ ์๋์ ์ฅ, ํ๋ฉด ์๋ ๊ฐฑ์ ๋ฑ์ด ์๋ค.
- ๋ฌดํ ๋ฃจํ์ ์กฐ๊ฑด๋ฌธ์ ์ด์ฉํด์ ์คํ ํ ๋๊ธฐํ๊ณ ์๋ค๊ฐ ํน์ ์กฐ๊ฑด์ด ๋ง์กฑ๋๋ฉด ์์ ์ ์ํํ๊ณ ๋ค์ ๋๊ธฐํ๋๋ก ์์ฑํ๋ค.
public void run() {
while(true) {
try {
Thread.sleep(3 * 100)
} catch(InterruptedException e) {}
if(autoSave) autoSave();
}
}
boolean isDaemon()
์ฐ๋ ๋๊ฐ ๋ฐ๋ชฌ ์ฐ๋ ๋์ธ์ง ํ์ธํ๋ค.
๋ฐ๋ชฌ ์ฐ๋ ๋์ด๋ฉด true๋ฅผ ๋ฐํํ๋ค.
void setDeamon(boolean on)
์ฐ๋ ๋๋ฅผ ๋ฐ๋ชฌ ์ฐ๋ ๋ ๋๋ ์ฌ์ฉ์ ์ฐ๋ ๋๋ก ๋ณ๊ฒฝํ๋ค.
๋งค๊ฐ๋ณ์ on์ ๊ฐ์ true๋ก ์ง์ ํ๋ฉด ๋ฐ๋ชฌ ์ฐ๋ ๋๊ฐ ๋๋ค.
start()๊ฐ ํธ์ถ๋๊ธฐ ์ ์ ์คํ๋์ด์ผ ํ๋ค.
๊ทธ๋ ์ง ์์ผ๋ฉด IllegalThreadStateException์ด ๋ฐ์ํ๋ค.
๋๊ธฐํ synchronization
๋ฉํฐ ์ฐ๋ ๋ ํ๋ก์ธ์ค์ ๊ฒฝ์ฐ,
์ฌ๋ฌ ์ฐ๋ ๋๊ฐ ๊ฐ์ ํ๋ก์ธ์ค ๋ด์ ์์์ ๊ณต์ ํด์ ์์ ํ๊ธฐ ๋๋ฌธ์ ์๋ก์ ์์ ์ ์ํฅ์ ์ฃผ๊ฒ๋๋ค.
์๋ ์๋ํ๋ ๊ฒ๊ณผ ๋ค๋ฅธ ๊ฒฐ๊ณผ๋ฅผ ์ป์ ์ ์๋ค.
์ด๋ฐ ์ผ์ ๋ฐฉ์งํ๊ธฐ ์ํด ํ ์ฐ๋ ๋๊ฐ ํน์ ์์ ์ ๋๋ง์น๊ธฐ ์ ๊น์ง ๋ค๋ฅธ ์ฐ๋ ๋์ ์ํด ๋ฐฉํด๋ฐ์ง ์๋๋ก ํ๋ ๊ฒ์ด ํ์ํ๋ค.
๋๊ธฐํ๋,
๊ณต์ ๋ ์์ ์ค์์ ๋์์ ์ฌ์ฉํ๋ฉด ์๋๋ ์์์ ๋ณดํธํ๋ ๋๊ตฌ์ด๋ค.
๊ณต์ ๋ฐ์ดํฐ๋ฅผ ์ฌ์ฉํ๋ ์ฝ๋ ์์ญ์ ์๊ณ ์์ญ์ผ๋ก ์ง์ ํด๋๊ณ ,
๊ณต์ ๋ฐ์ดํฐ(๊ฐ์ฒด)๊ฐ ๊ฐ์ง๊ณ ์๋ lock๋ฅผ ํ๋ํ ๋จ ํ๋์ ์ฐ๋ ๋๋ง ์ด ์์ญ ๋ด์ ์ฝ๋๋ฅผ ์ํํ ์ ์๊ฒ ํ๋ค.
ํด๋น ์ฐ๋ ๋๊ฐ ์๊ณ ์์ญ ๋ด์ ๋ชจ๋ ์ฝ๋๋ฅผ ์ํํ๊ณ ๋ฒ์ด๋์ lock๋ฅผ ๋ฐ๋ฉํด์ผ๋ง
๋ค๋ฅธ ์ฐ๋ ๋๊ฐ ๋ฐ๋ฉ๋ lock๋ฅผ ํ๋ํ์ฌ ์๊ณ ์์ญ์ ์ฝ๋๋ฅผ ์ํํ ์ ์๋ค.
1. ๋ฉ์๋ ์ ์ฒด๋ฅผ ์๊ณ ์์ญ์ผ๋ก ์ง์
- ๋ฉ์๋ ์์ synchronized๋ฅผ ๋ถ์ธ๋ค.
- ๋ฉ์๋ ์ ์ฒด๊ฐ ์๊ณ ์์ญ์ผ๋ก ์ค์ ๋๋ค.
- ์ฐ๋ ๋๋ synchronized ๋ฉ์๋๊ฐ ํธ์ถ๋ ์์ ๋ถํฐ ํด๋น ๋ฉ์๋๊ฐ ํฌํจ๋ ๊ฐ์ฒด์ lock์ ์ป์ด ์์ ์ ์ํํ๊ณ
- ๋ฉ์๋๊ฐ ์ข ๋ฃ๋๋ฉด lock๋ฅผ ๋ฐํํ๋ค.
public synchronized void calcSum {
// ์๊ณ ์์ญ
}
2. ํน์ ํ ์์ญ์ ์๊ณ ์์ญ์ผ๋ก ์ง์
- ๋ฉ์๋ ๋ด์ ์ฝ๋ ์ผ๋ถ๋ฅผ ๋ธ๋ญ { } ์ผ๋ก ๊ฐ์ธ๊ณ ๋ธ๋ญ ์์ synchronized๋ฅผ ๋ถ์ธ๋ค.
- ์ด๋ ์ฐธ์กฐ๋ณ์๋ lock์ ๊ฑธ๊ณ ์ ํ๋ ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ๋ ๊ฒ์ด์ด์ผ ํ๋ค.
- ์ด ๋ธ๋ญ์ synchronized ๋ธ๋ญ์ด๋ผ๊ณ ๋ถ๋ฅด๋ฉฐ,
- ์ด ๋ธ๋ญ ์์ญ ์์ผ๋ก ๋ค์ด๊ฐ๋ฉด์๋ถํฐ ์ฐ๋ ๋๋ ์ง์ ๋ ๊ฐ์ฒด์ lock์ ์ป๊ฒ๋๊ณ , ์ด ๋ธ๋ญ์ ๋ฒ์ด๋๋ฉด lock๋ฅผ ๋ฐํํ๋ค.
synchronized(๊ฐ์ฒด์ ์ฐธ์กฐ๋ณ์){
// ์๊ณ ์์ญ
}
Lock
- ๋ชจ๋ ๊ฐ์ฒด๋ lock์ ํ๋์ฉ ๊ฐ๊ณ ์๋ค.
- ํด๋น ๊ฐ์ฒด์ lock์ ๊ฐ์ง๊ณ ์๋ ์ฐ๋ ๋๋ง ์๊ณ ์์ญ์ ์ฝ๋๋ฅผ ์ํํ ์ ์๋ค.
- ๋ค๋ฅธ ์ฐ๋ ๋๋ค์ lock์ ์ป์ ๋๊น์ง ๊ธฐ๋ค๋ฆฌ๊ฒ ๋๋ค.
- ์๊ณ ์์ญ์ ๋ฉํฐ์ฐ๋ ๋ ํ๋ก๊ทธ๋จ์ ์ฑ๋ฅ์ ์ข์ฐํ๊ธฐ ๋๋ฌธ์,
- ๊ฐ๋ฅํ๋ฉด ๋ฉ์๋ ์ ์ฒด์ ๋ฝ์ ๊ฑฐ๋ ๊ฒ๋ณด๋ค synchronized ๋ธ๋ญ์ผ๋ก ์๊ณ ์์ญ์ ์ต์ํํด์ ๋ณด๋ค ํจ์จ์ ์ธ ํ๋ก๊ทธ๋จ์ด ๋๋๋ก ํด์ผํ๋ค.
๋ฐ๋๋ฝ DeadLock
- ๊ต์ฐฉ ์ํ
- ํ ์์์ ์ฌ๋ฌ ์์คํ ์ด ์ฌ์ฉํ๋ ค๊ณ ํ ๋ ๋ฐ์
- ๋ ์ด์์ ์ฐ๋ ๋๊ฐ lock์ ํ๋ํ๊ธฐ ์ํด ๋๊ธฐ์ค์ธ๋ฐ lock์ ์ก๊ณ ์๋ ์ฐ๋ ๋๋ค๋ ๋๊ฐ์ด ๋ค๋ฅธ lock๋ฅผ ๊ธฐ๋ค๋ฆฌ๋ฉด์ ์๋ก block ์ํ์ ๋์ธ ์ํ
- ์๋ก ์๋๋ฐฉ์ ์์ ์ด ๋๋ ๋๊น์ง ๊ธฐ๋ค๋ฆฌ๋ ๋ฌดํ ๋๊ธฐ ์ํ
๋ฐ๋๋ฝ ๋ฐ์์กฐ๊ฑด
๋ค๊ฐ์ง ์กฐ๊ฑด์ด ๋์์ ์ฑ๋ฆฝ๋ ๋ ๋ฐ์
1. ์ํธ ๋ฐฐ์ฌ Mutual exclusion
- ์์์ ํ ๋ฒ์ ํ ํ๋ก์ธ์ค๋ง์ด ์ฌ์ฉํ ์ ์์ด์ผ ํ๋ค.
2. ์ ์ ๋๊ธฐ (Hold and wait)
- ์ต์ํ ํ๋์ ์์์ ์ ์ ํ๊ณ ์์ผ๋ฉด์ ๋ค๋ฅธ ํ๋ก์ธ์ค์ ํ ๋น๋์ด ์ฌ์ฉํ๊ณ ์๋ ์์์ ์ถ๊ฐ๋ก ์ ์ ํ๊ธฐ ์ํด ๋๊ธฐํ๋ ํ๋ก์ธ์ค๊ฐ ์์ด์ผ ํ๋ค.
3. ๋น์ ์ (No preemption)
- ๋ค๋ฅธ ํ๋ก์ธ์ค์ ํ ๋น๋ ์์์ ์ฌ์ฉ์ด ๋๋ ๋๊น์ง ๊ฐ์ ๋ก ๋นผ์์ ์ ์์ด์ผ ํ๋ค.
4. ์ํ ๋๊ธฐ (Circular wait)
- ํ๋ก์ธ์ค์ ์งํฉ {P0, P1, ,…Pn}์์ P0๋ P1์ด ์ ์ ํ ์์์ ๋๊ธฐํ๊ณ P1์ P2๊ฐ ์ ์ ํ ์์์ ๋๊ธฐํ๊ณ P2…Pn-1์ Pn์ด ์ ์ ํ ์์์ ๋๊ธฐํ๋ฉฐ Pn์ P0๊ฐ ์ ์ ํ ์์์ ์๊ตฌํด์ผ ํ๋ค.
์ฐธ์กฐ
10์ฃผ์ฐจ ๊ณผ์ : ๋ฉํฐ์ฐ๋ ๋ ํ๋ก๊ทธ๋๋ฐ
๋จ๊ถ์ฑ, ์๋ฐ์ ์ ์ ๊ธฐ์ดํธ, ๋์ฐ์ถํ, 2019
์ฒ์ธ๊ตญ, ์ด์์ JAVA๋ ์ฒ์์ด์ง!, INFINITYBOOKS, 2015
'Programming > JAVA' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Java] ์ ๋ ธํ ์ด์ (1) | 2022.09.11 |
---|---|
[Java] Enum (1) | 2022.09.08 |
[Java] ์์ธ ์ฒ๋ฆฌ (0) | 2022.09.01 |
[Java] ์ธํฐํ์ด์ค (1) | 2022.08.29 |
[Java] ํจํค์ง (0) | 2022.08.17 |