티스토리 뷰
주의 사항!
- 이 글은 제가 직접 공부하는 중에 작성되고 있습니다.
- 따라서 제가 이해하는 그대로의 내용이 포함됩니다.
- 따라서 이 글은 사실과는 다른 내용이 포함될 수 있습니다.
사용자는 미디어 플레이어에서 동영상을 보다가 일시 정지시킬 수도 있고, 종료시킬 수도 있습니다. 일시 정지는 조금 후 다시 동영상을 보겠다는 의미이므로 미디어 플레이어는 동영상 스레드를 일시 정지 상태로 만들어야 합니다. 그리고 종료는 더 이상 동영상을 보지 않겠다는 의미이므로 미디어 플레이어는 스레드를 종료 상태로 만들어야 합니다. 이와 같이 스레드의 상태를 변경하는 것을 스레드 상태 제어라고 합니다.
멀티 스레드 프로그램을 만들기 위해서는 정교한 스레드 상태 제어가 필요합니다. 상태 제어가 잘못되면 프로그램은 불안정해져서 먹통이 되거나 다운됩니다. 멀티 스레드 프로그래밍이 어렵다고 하는 이유가 바로 여기에 있습니다. 스레드는 잘 사용하면 약이 되지만, 잘못 사용하면 치명적인 프로그램 버그가 되기 때문에 스레드를 정확하게 제어하는 방법을 잘 알고 있어야 합니다.
스레드 상태 제어를 제대로 하기 위해서는 스레드의 상태 변화를 가져오는 메서드들을 파악하고 있어야 합니다.
| 메서드 | 설명 |
| interrupt() | 일시 정지 상태의 스레드에서 interruptedException 예외를 발생시켜, 예외 처리 코드(catch)에서 실행 대기 상태로 가거나 종료 상태로 갈 수 있도록 합니다. |
| notify() notifyAll() |
동기화 블록 내에서 wait() 메서드에 의해 일시 정지 상태에 있는 스레드를 실행 대기 상태로 만듭니다. |
| resume() | suspend() 메서드에 의해 일시 정지 상태에 있는 스레드를 실행 대기 상태로 만듭니다. 이 메서드는 Deprecated 메서드로 권하지 않기 때문에 대신 notiry(), notifyAll() 메서드를 사용합니다. |
| sleep(long millis) sleep(long millis, int nanos) |
주어진 시간 동안 스레드를 일시 정지 상태로 만듭니다. 주어진 시간이 지나면 자동적으로 실행 대기 상태가 됩니다. |
| join() join(long millis) join(long millis, int nanos) |
join() 메서드를 호출한 스레드는 일시 정지 상태가 됩니다. 실행 대기 상태로 가려면 join() 메서드를 멤버로 가지는 스레드가 종료되거나, 매개 값으로 주어진 시간이 지나야 합니다. |
| wait() wait(long millis) wait(long millis, int nanos) |
동기화(Synchronized) 블록 내에서 스레드를 일시 정지 상태로 만듭니다. 매개 값으로 주어진 시간이 지나면 자동적으로 실행 대기 상태가 됩니다. 시간이 주어지지 않으면 notify(), notifyAll() 메서드에 의해 실행 대기 상태로 갈 수 있습니다. |
| suspend() | 스레드를 일시 정지 상태로 만듭니다. resume() 메서드를 호출하면 다시 실행 대기 상태가 됩니다. 이 메서드는 Deprecated 메서드로 권하지 않기때문에 대신 wait() 메서드를 사용합니다. |
| yield() | 실행 중에 우선순위가 동일한 다른 스레드에게 실행을 양보하고 실행 대기 상태가 됩니다. |
| stop() | 스레드를 즉시 종료시킵니다. 이 메서드는 Deprecated 메서드로 권하지 않습니다. |
위 표에서 wait(), notify(), notifyAll()은 Object 클래스의 메서드이고, 그 이외의 메서드들은 모두 Thread 클래스의 메서드들입니다. wait(), notify(), notifyAll() 메서드의 사용 방법은 스레드의 동기화에서 자세히 알아보고, 이번에는 Thread 클래스의 메서드들을 먼저 살펴보겠습니다.
1. 주어진 시간 동안 일시 정지 : sleep()
다음과 같이 Thread.sleep() 메서드를 호출한 스레드는 주어진 시간 동안 일시 정지 상태가 되고, 다시 실행 대기 상태로 돌아갑니다.
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
//interrupt() 메서드가 호출되면 실행
}매개 값에는 얼마 동안 일시 정지 상태로 있을 것인지, 밀리세컨드(㎳) 단위로 시간을 주면 됩니다. 일시 정지 상태에서 주어진 시간이 되기 전에 interrupt() 메서드가 호출되면 interruptedException 예외가 발생하기 때문에 예외 처리가 필요합니다.
다음 예제는 3초 주기로 비프(beep) 음을 10번 발생시킵니다.
//Main.java
package Example;
import java.awt.Toolkit;
public class Main {
public static void main(String[] args) {
Toolkit toolkit = Toolkit.getDefaultToolkit();
for(int i = 0; i < 10; i++) {
toolkit.beep();
try {
Thread.sleep(3000);
} catch(InterruptedException e) {}
}
}
}
2. 다른 스레드에게 실행 양보 : yield()
스레드가 처리하는 작업은 반복적인 실행을 위해 for문이나 while문을 포함하는 경우가 많습니다. 가끔은 이 반복문들이 무의미한 반복을 하는 경우가 있습니다. 다음 코드를 보겠습니다.
public void run() {
while(true) {
if(work) {
System.out.println("ThreadA 작업 내용");
}
}
}스레드가 시작되어 run() 메서드를 실행하면 while(true) { } 블록을 무한 반복 실행합니다. 만약 work의 값이 false라면 그리고 work의 값이 false에서 true로 변경되는 시점이 불분명하다면, while문은 어떠한 실행문도 실행하지 않고 무의미한 반복을 하게 됩니다. 이것보다는 다른 스레드에게 실행을 양보하고 자신은 실행 대기 상태로 가는 것이 전체 프로그램 성능에 도움이 됩니다.
이런 기능을 위해서 스레드는 yield() 메서드를 제공하고 있습니다. yield() 메서드를 호출한 스레드는 실행 대기 상태로 돌아가고 동일한 우선순위 또는 높은 우선순위를 갖는 다른 스레드가 실행 기회를 가질 수 있도록 해줍니다.
다음 코드는 의미 없는 반복을 줄이기 위해 yield() 메서드를 호출해서 다른 스레드에게 실행 기회를 주도록 수정한 것입니다.
public void run() {
while(true) {
if(work) {
System.out.println("ThreadA 작업 내용");
} else {
Thread.yield();
}
}
}
다음 예제는 처음 실행 후 처음 2밀리 세컨드 동안은 ThreadA와 ThreadB가 번갈아가며 실행됩니다. 2밀리 세컨드 이후에는 ThreadA의 work를 flase로 변경하여 ThreadA가 yield() 메서드를 호출하게 합니다. 이 동안에는 ThreadB가 더 많은 실행 기회를 가집니다. 다시 2밀리 세컨드 후에는 ThreadA의 work를 true로 변경하고 다음 2밀리 세컨드 후에는 두 스레드 모두 stop을 true로 변경하여 실행을 종료합니다.
//ThreadA.java
package Example;
public class ThreadA extends Thread {
public boolean stop = false; //종료 플래그
public boolean work = true; //작업 진행 여부 플래그
public void run() {
while(!stop) {
if(work) {
System.out.println("ThreadA 작업 내용");
} else {
Thread.yield();
}
}
System.out.println("ThreadA 종료!");
}
}
//ThreadB.java
package Example;
public class ThreadB extends Thread {
public boolean stop = false;
public boolean work = true;
public void run() {
while(!stop) {
if(work) {
System.out.println("ThreadB 작업 내용");
} else {
Thread.yield();
}
}
System.out.println("ThreadB 종료!");
}
}
//Main.java
package Example;
public class Main {
public static void main(String[] args) {
ThreadA threadA = new ThreadA();
ThreadB threadB = new ThreadB();
System.out.println("--------------------------시작--------------------------");
threadA.start();
threadB.start();
try {
Thread.sleep(2);
} catch (InterruptedException e) {}
System.out.println("ThreadA work : false");
threadA.work = false;
try {
Thread.sleep(2);
} catch(InterruptedException e) {}
System.out.println("ThreadA work : ture");
threadA.work = true;
try {
Thread.sleep(2);
} catch(InterruptedException e) {}
threadA.stop = true;
threadB.stop = true;
}
}
3. 다른 스레드의 종료를 기다림 : join()
스레드는 다른 스레드와 독립적으로 실행하는 것이 기본이지만 다른 스레드가 종료될 때까지 기다렸다가 실행해야 하는 경우가 발생할 수 있습니다. 예를 들어 계산 작업을 하는 스레드가 모든 계산 작업을 마쳤을 때, 계산 결괏값을 받아 이용하는 경우가 이에 해당합니다.
ThreadA가 ThreadB의 join() 메서드를 호출하면 ThreadA는 ThreadB가 종료될 때까지 일시 정지 상태가 됩니다. ThreadB의 run() 메서드가 종료되면 비로소 ThreadA는 일시 정지에서 풀려 다음 코드를 실행하게 됩니다.
다음 예제를 보면 메인 스레드는 SumThread가 계산 작업을 모두 마칠 때까지 일시 정지 상태에 있다가 SumThread가 최종 계산된 결괏값을 산출하고 종료하면 결괏값을 받아 출력합니다.
//SumThread.java
package Example;
public class SumThread extends Thread {
private long sum;
public long getSum() {
return sum;
}
public void setSum(long sum) {
this.sum = sum;
}
@Override
public void run() {
for(int i = 1; i <= 100; i++) {
sum += i;
}
}
}
//Main.java
package Example;
public class Main {
public static void main(String[] args) {
SumThread sumThread = new SumThread();
sumThread.start();
try {
sumThread.join();
} catch (InterruptedException e) {}
System.out.println("1 ~ 100의 합 : " + sumThread.getSum());
}
}
/*
실행결과
1 ~ 100의 합 : 5050
*/
4. 스레드 간 협업 : wait(), notify(), notifyAll()
경우에 따라서는 두 개의 스레드를 교대로 번갈아가며 실행해야 할 경우가 있습니다. 정확한 교대 작업이 필요할 경우, 자신의 작업이 끝나면 상대방 스레드를 일시 정지 상태에서 풀어주고, 자신은 일시 정지 상태로 만드는 것입니다.
이 방법의 핵심은 공유 객체에 있습니다. 공유 객체는 두 스레드가 작업할 내용을 각각 동기화 메서드로 구분해 놓습니다. 한 스레드가 작업을 완료하면 notify() 메서드를 호출해서 일시 정지 상태에 있는 다른 스레드를 실행 대기 상태로 만들고, 자신은 두 번 작업을 하지 않도록 wait() 메서드를 호출하여 일시 정지 상태로 만듭니다.
만약 wait() 대신 wait(long timeout)이나, wait(long timeout, int nanos)를 사용하면 notify()를 호출하지 않아도 지정된 시간이 지나면 스레드가 자동적으로 실행 대기 상태가 됩니다. notify() 메서드와 동일한 역할을 하는 notifyAll() 메서드도 있는데, notify()는 wait()에 의해 일시 정지된 스레드 중 한 개를 실행 대기 상태로 만들고, notifyAll() 메서드는 wait()에 의해 일시 정지된 모든 스레드들을 실행 대기 상태로 만듭니다.
이 메서드들은 Thread 클래스가 아닌, Object 클래스에 선언된 메서드이므로 모든 공유 객체에서 호출이 가능합니다. 주의할 점은 이 메서드들은 동기화 메서드 또는 동기화 블록 내에서만 사용할 수 있다는 것입니다.
다음 예제는 두 스레드의 작업을 WorkObject의 methodA()와 methodB()에 정의해 두고, 두 스레드 ThreadA와 ThreadB가 교대로 methodA()와 methodB()를 호출하도록 했습니다.
//WorkObject.java
package Example;
public class WorkObject {
public synchronized void methodA() {
System.out.println("ThreadA의 methodA() 작업 실행");
notify();
try {
wait();
} catch(InterruptedException e) {}
}
public synchronized void methodB() {
System.out.println("ThreadB의 methodB() 작업 실행");
notify();
try {
wait();
} catch(InterruptedException e) {}
}
}
//ThreadA.java
package Example;
public class ThreadA extends Thread {
private WorkObject workObject;
public ThreadA(WorkObject workObject) {
this.workObject = workObject;
}
@Override
public void run() {
for(int i = 0; i < 10; i++) {
workObject.methodA();
}
}
}
//ThreadB.java
package Example;
public class ThreadB extends Thread {
private WorkObject workObject;
public ThreadB(WorkObject workObject) {
this.workObject = workObject;
}
@Override
public void run() {
for(int i = 0; i < 10; i++) {
workObject.methodB();
}
}
}
//Main.java
package Example;
public class Main {
public static void main(String[] args) {
WorkObject sharedObject = new WorkObject();
ThreadA threadA = new ThreadA(sharedObject);
ThreadB threadB = new ThreadB(sharedObject);
threadA.start();
threadB.start();
}
}
5. 스레드의 안전한 종료 : stop 플래그, interrupt()
스레드는 자신의 run() 메서드가 모두 실행되어야 종료됩니다. 하지만 경우에 따라서는 실행 중인 스레드를 즉시 종료할 필요가 있습니다. 예를 들어 동영상을 끝까지 보지 않고, 사용자가 멈춤을 요구할 경우 그렇습니다.
Thread는 스레드를 즉시 종료시키기 위해서 stop() 메서드를 제공하고 있는데, 이 메서드는 Deprecated 되었습니다. 이유는 stop() 메서드로 스레드를 갑자기 종료하게 되면 스레드가 사용 중이던 자원들이 불안전한 상태로 남겨지기 때문입니다. 여기서 자원이란, 파일, 네트워크 연결 등을 말합니다. 그렇다면 스레드를 즉시 종료하기 위한 최선의 방법은 무엇일까요?
5. 1. stop 플래그를 이용하는 방법
스레드는 run() 메서드가 끝나면 자동으로 종료되기 때문에 run() 메서드가 정상적으로 종료되도록 유도하는 것이 최선의 방법입니다. 다음 코드는 stop 플래그를 이용해서 run() 메서드의 종료를 유도합니다.
public class XXXThread extends Thread {
private boolean stop;
public void run() {
while(!stop) {
//스레드가 반복 실행할 코드;
}
//스레드가 사용한 자원 정리
}
}위 코드에서 stop 필드가 false일 경우에는 while문의 조건식이 true가 되어 반복 실행하지만, stop 필드가 true일 경우에는 while문의 조건식이 false가 되어 while문을 빠져나옵니다. 그리고 스레드가 사용한 자원을 정리하고, run() 메서드가 끝나게 됨으로써 스레드는 안전하게 종료됩니다.
다음 예제는 PrintThread을 실행한 후 1초 후에 PrintThread을 멈추도록 setStop() 메서드를 호출합니다.
//PrintThread.java
package Example;
public class PrintThread extends Thread {
private boolean stop;
public void setStop(boolean stop) {
this.stop = stop;
}
@Override
public void run() {
while (!stop) {
System.out.println("실행 중");
}
System.out.println("자원 정리");
System.out.println("실행 종료");
}
}
//Main.java
package Example;
public class Main {
public static void main(String[] args) {
PrintThread printThread = new PrintThread();
printThread.start();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {}
printThread.setStop(true);
}
}
/*
실행결과
...
실행 중
실행 중
실행 중
실행 중
실행 중
실행 중
실행 중
자원 정리
실행 종료
*/
5. 2. interrupt() 메서드를 이용하는 방법
interrupt() 메서드는 스레드가 일시 정지 상태에 있을 때 InterruptedException 예외를 발생시키는 역할을 합니다. 이것을 이용하면 run() 메서드를 정상 종료시킬 수 있습니다.
예를 들어 ThreadA에서 ThreadB를 실행했다고 가정해 보겠습니다. ThreadA가 ThreadB의 interrupt() 메서드를 실행하게 되면 ThreadB가 sleep() 메서드로 일시 정지 상태가 될 때 ThreadB에서 InterruptedException 예외가 발생하게 됩니다.
다음 예제는 PrintThread를 실행한 후 1초 후에 PrintThread를 멈추도록 interrupt() 메서드를 호출합니다.
//PrintThread.java
package Example;
public class PrintThread extends Thread {
@Override
public void run() {
try {
while (true) {
System.out.println("실행 중");
Thread.sleep(1);
}
} catch (InterruptedException e) {}
System.out.println("자원 정리");
System.out.println("실행 종료");
}
}
//Main.java
package Example;
public class Main {
public static void main(String[] args) {
PrintThread printThread = new PrintThread();
printThread.start();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {}
printThread.interrupt();
}
}
/*
실행결과
...
실행 중
실행 중
실행 중
실행 중
실행 중
자원 정리
실행 종료
*/주목할 점은 스레드가 실행 대기 또는 실행 상태에 있을 때 interrupt() 메서드가 실행되면 즉시 InterruptedException 예외가 발생하지 않고, 스레드가 미래에 일시 정지 상태가 되면 InterruptedException 예외가 발생한다는 것입니다. 따라서 스레드가 일시 정지 상태가 되지 않으면 interrupt() 메서드 호출은 아무런 의미가 없습니다. 그래서 짧은 시간이나마 일시 정지시키기 위해 Thread.sleep(1)을 사용했습니다.
일시 정지를 만들지 않고도 interrupt() 호출 여부를 알 수 있는 방법이 있습니다. interrupted() 메서드가 호출되었다면 스레드의 interrupted()와 isInterrupted() 메서드는 true를 리턴합니다. interrupted() 메서드는 정적 메서드이고, isInterrupted()는 인스턴스 메서드입니다. 둘 중 어느 것을 사용해도 좋습니다.
다음은 PrintThread를 수정한 것입니다. 일시 정지 코드인 Thread.sleep(1)을 사용하지 않고, Thread.interrupted()를 사용해서 PrintThread의 interrupt()가 호출되었는지 확인한 다음 while문을 빠져나가도록 했습니다.
//PrintThread.java
package Example;
public class PrintThread extends Thread {
@Override
public void run() {
while (true) {
System.out.println("실행 중");
if(Thread.interrupted()) {
break;
}
}
System.out.println("자원 정리");
System.out.println("실행 종료");
}
}
'공부 일지 > JAVA 공부 일지' 카테고리의 다른 글
| 자바, 스레드 그룹 (2) | 2021.04.27 |
|---|---|
| 자바, 데몬 스레드 (2) | 2021.04.27 |
| 자바, 스레드 상태 (0) | 2021.04.26 |
| 자바, 동기화 메서드와 동기화 블록 (0) | 2021.04.26 |
| 자바, 스레드 우선 순위 (0) | 2021.04.26 |