섹션5. 스레드 제어와 생명주기2 (1)

[ilikeram]

📌  인터럽트

package thread.control.interrupt;

import static util.MyLogger.log;
import static util.ThreadUtils.sleep;

public class ThreadStopMainV1 {

    public static void main(String[] args) {
        MyTask task = new MyTask();
        Thread thread = new Thread(task, "work");
        thread.start();

        sleep(4000);
        log("작업 중단 지시 runFlag=false");
        task.runFlag = false; // work 스레드의 작업중단을 지시 
    }

    static class MyTask implements Runnable {
				
				// volatile: 여러 스레드에서 공유하는 값에 사용하는 키워드
        volatile boolean runFlag = true; 

        @Override
        public void run() {
            while (runFlag) {
                log("작업 중");
                sleep(3000);
            }
            log("자원 정리");
            log("자원 종료");
        }
    }
}

23:31:00.164 [     work] 작업 중
23:31:03.173 [     work] 작업 중
23:31:04.084 [     main] 작업 중단 지시 runFlag=false
23:31:06.179 [     work] 자원 정리
23:31:06.179 [     work] 자원 종료

• 프로그램 시작 후 4초 뒤에 main 스레드는 runFlag를 false 로 변경 → work 스레드는 while(runFlag)에서 runFlag 조건이 false 로 변한것을 확인하고 while 문을 빠져나가면서 작업 종료

❗️문제점

• main 스레드가 runFlag=false를 통해 작업 중단을 지시해도, work 스레드가 즉각 반응하지 않는다. ⇒ 로그를 확인해보면 작업 중단 지시 2초 정도 이후에 자원을 정리하고 작업을 종료한다.

• 이 방식의 가장 큰 문제는 다음 코드의 sleep()에 있다.

   while (runFlag) { log("작업 중");
        sleep(3000); 
    }

  • main 스레드가 runFlag를 false로 변경해도 work 스레드는 sleep(3000)을 통해 3초간 잠들어있다. ⇒ 3초간의 잠이 깬 다음에 while(runFlag) 코드를 실행해야, runFlag를 확인하고 작업을 중단할 수 있다.
  • 참고로 runFlag를 변경한 후 2초라는 시간이 지난 이후에 작업이 종료되는 이유는 work 스레드가 3초에 한번씩 깨어나서 runFlag를 확인하는데 ,main 스레드가 4초에 runFlag를 변경했기 때문

• Thread.sleep()을 통해 쉬고 있는데, 처리해야 하는 작업이 들어와서 해당 스레드를 급하게 깨우거나, sleep()으로 쉬고있는 스레드에게 더는 일이 없으니 작업종료를 지시할 수 있다. ⇒ 인터럽트 사용

• 인터럽트를 사용하면 WAITING, TIMED_WAITING 같은 대기 상태의 스레드를 직접 깨워서 작동하는 RUNNABLE 상태로 만들 수 있다.

package thread.control.interrupt;

import static util.MyLogger.log;
import static util.ThreadUtils.sleep;

public class ThreadStopMainV2 {

    public static void main(String[] args) {
        MyTask task = new MyTask();
        Thread thread = new Thread(task, "work");
        thread.start();

        sleep(4000);
        log("작업 중단 지시 thread.interrupt()");
        thread.interrupt(); // 해당 스레드에 인터럽트가 발생 
        log("work 스레드 인터럽트 상태1 = " + thread.isInterrupted());
    }

    static class MyTask implements Runnable {

        @Override
        public void run() {
            try {
                while (true) {
                    log("작업 중");
                    Thread.sleep(3000);
                }
            } catch (InterruptedException e) { // 인터럽트 발생 ->InterruptedException 발생
                log("work 스레드 인터럽트 상태2 = " + Thread.currentThread().isInterrupted());
                log("interrupt message=" + e.getMessage());
                log("state=" + Thread.currentThread().getState());
            }
            log("자원 정리");
            log("자원 종료");
        }
    }
}

• 예제의 run() 에서는 인터럽트를 이해하기 위해 직접만든 sleep() 대신 Thread.sleep() 사용하고, try~catch 사용
• 특정 스레드의 인스턴스에 interrupt() 메서드를 호출하면, 해당 스레드에 인터럽트 발생
• 인터럽트가 발생하면 해당 스레드에 InterruptedException 발생
  • 인터럽트를 받은 스레드는 대기상태에서 깨어나 RUNNABLE 상태가 되고, 코드는 정상 수행
  • InterruptedException을 catch로 잡아서 정상 흐름으로 변경하면 된다.
• 참고로 interrupt()를 호출했다고 해서 즉각 InterruptedException이 발생하는 것은 아니다. sleep()처럼 InterruptedException을 던지는 메서드를 호출하거나 또는 호출중일때 예외가 발생
  • 위 코드에서 while(true), log(”작업 중”)에서는 InterruptedException이 발생하지 않는다.
  • Thread.sleep() 처럼 InterruptedException을 던지는 메서드를 호출하거나 또는 호출하며 대기중일때 예외가 발생

00:05:44.290 [     work] 작업 중
00:05:47.296 [     work] 작업 중
00:05:48.249 [     main] 작업 중단 지시 thread.interrupt()
00:05:48.259 [     work] work 스레드 인터럽트 상태2 = false
00:05:48.259 [     main] work 스레드 인터럽트 상태1 = true
00:05:48.259 [     work] interrupt message=sleep interrupted
00:05:48.260 [     work] state=RUNNABLE
00:05:48.261 [     work] 자원 정리
00:05:48.261 [     work] 자원 종료

• thread.interrupt()를 통해 작업 중단을 지시하고, 거의 즉각적으로 인터럽트가 발생
• 이 때 work 스레드는 TIMED_WATING → RUNNABLE 상태로 변경되면서 InterruptedException 예외가 발생
  • 참고로 스레드가 RUNNABLE 상태여야 catch 예외 코드도 실행될 수 있다.
• 실행결과를 보면 work 스레드가 catch 블럭안에서 RUNNABLE 상태로 바뀐것을 확인할 수 있다.

• main 스레드가 4초 뒤에 work 스레드에 interrupt()를 건다.
• work 스레드는 인터럽트 상태(true)가 된다.
• 스레드가 인터럽트 상태일 때는 sleep()처럼 InterruptedException이 발생하는 메서드를 호출하거나 또는 이미 호출하고 대기중이라면 InterruptedException이 발생한다.
• 이때 2가지 일이 발생한다.
  • work 스레드는 TIMED_WAITING 상태에서 RUNNABLE 상태로 변경되고, InterruptedException 예외를 처리하면서 반복문을 탈출
  • work 스레드는 인터럽트 상태가 되었고, 인터럽트 상태이기 때문에 인터럽트 예외가 발생
  • 인터럽트 상태에서 인터럽트 예외가 발생하면 work 스레드는 다시 작동하는 상태가 된다. 따라서 work 스레드의 인터럽트 상태는 종료된다. → work 스레드의 인터럽트 상태는 false 로 변경된다.
• 인터럽트가 적용되고, 인터럽트 예외가 발생하면 해당 스레드는 실행가능 상태가 되고, 인터럽트 발생 상태도 정상으로 돌아온다.
• 인터럽트를 사용하면 대기중인 스레드를 바로 깨워서 실행가능한 상태로 바꿀수 있다. ⇒ runFlag를 사용하는 이전 방식보다 반응성이 좋아진 것을 확인할 수 있다.

❗️위 코드에서 한가지 아쉬운 부분

while (true) { //인터럽트 체크 안함 
	log("작업 중");
	Thread.sleep(3000); //여기서만 인터럽트 발생 
}

• while(true) 부분은 인터럽트 체크를 하지 않는다. → 인터럽트가 발생해도 이 부분은 항상 true 이기 때문에 다음 코드로 넘어간다. 그리고 sleep()을 호출하고 나서야 인터럽트 발생한다.
• 다음과 같이 인터럽트의 상태를 확인하면 더 빨리 반응할 수 있다.

while (인터럽트_상태_확인) { //여기서도 인터럽트 상태 체크 
	log("작업 중");
	Thread.sleep(3000); //인터럽트 발생 
}

• 이 코드와 같이 인터럽트 상태를 확인하면 while문을 체크하는 부분에서 더 빠르게 while 문을 빠져나갈 수 있다.
• 추가로 인터럽트 상태를 직접확인하면 인터럽트를 발생시키는 sleep()과 같은 코드가 없어도 while 문을 빠져나갈 수 있다.

package thread.control.interrupt;

import static util.MyLogger.log;
import static util.ThreadUtils.sleep;

public class ThreadStopMainV3 {

    public static void main(String[] args) {
        MyTask task = new MyTask();
        Thread thread = new Thread(task, "work");
        thread.start();

        sleep(100); // 시간을 줄임
        log("작업 중단 지시 thread.interrupt()");
        thread.interrupt();
        log("work 스레드 인터럽트 상태1 = " + thread.isInterrupted());
    }

    static class MyTask implements Runnable {

        @Override
        public void run() {
            while (!Thread.currentThread().isInterrupted()) { // 인터럽트 상태 변경X
                log("작업 중"); // run()반복문에서 sleep() 제거
            }
            log("work 스레드 인터럽트 상태2 = " + Thread.currentThread().isInterrupted());

            try {
                log("자원 정리");
                Thread.sleep(1000);
                log("자원 종료");
            } catch (InterruptedException e) {
                log("자원 정리 실패 - 자원 정리 중 인터럽트 발생");
                log("work 스레드 인터럽트 상태3 = " + Thread.currentThread().isInterrupted());
            }
            log("작업 종료");
        }
    }
}

...
23:48:42.838 [     work] 작업 중
23:48:42.800 [     main] 작업 중단 지시 thread.interrupt()
23:48:42.839 [     work] 작업 중
23:48:42.847 [     main] work 스레드 인터럽트 상태1 = true
23:48:42.848 [     work] work 스레드 인터럽트 상태2 = true
23:48:42.849 [     work] 자원 정리
23:48:42.849 [     work] 자원 정리 실패 - 자원 정리 중 인터럽트 발생
23:48:42.850 [     work] work 스레드 인터럽트 상태3 = false
23:48:42.850 [     work] 작업 종료

• 주요 실행 순서

  • main 스레드는 interrupt() 메서드를 사용해서, work 스레드에 인터럽트를 건다.
  • work 스레드는 인터럽트 상태이다. isInterrupted() = true가 된다.
  • 이때 다음과 같이 while 조건이 false 가 되면서 while문을 탈출한다.
    • while(!Thread.currentThread().isInterrupted())
    • while(!True)
    • while(false)

• 이 코드의 문제점

  • work 스레드의 인터럽트 상태가 true 로 계속 유지된다는 점
  • 인터럽트 예외가 터진경우 스레드의 인터럽트 상태는 false 가 된다. 반면에 isInterrupted() 메서드는 인터럽트의 상태를 변경하지 않는다. 단순히 인터럽트의 상태를 확인만 한다.
  • work 스레드는 이후에 자원을 정리하는 코드를 실행하는데, 이때도 인터럽트의 상태는 계속 true로 유지된다. 이 때 만약 인터럽트를 발생하는 sleep()과 같은 코드를 수행한다면, 해당 코드에서 인터럽트 예외가 발생하게 된다.
  • 결과적으로 자원정리를 하는 도중에 인터럽트가 발생해서 자원정리에 실패한다.
  • 자바에서 인터럽트 예외가 한 번 발생하면, 스레드의 인터럽트 상태를 다시 정상(false)로 돌리는 것은 이런 이유 때문으로 스레드의 인터럽트 상태를 정상으로 돌리지 않으면 이후에도 계속 인터럽트가 발생하게 된다.

  ❗️인터럽트의 목적을 달성하면 인터럽트 상태를 다시 정상으로 돌려두어야 한다.

Thread.interrupted()

• 스레드의 인터럽트 상태를 단순히 확인만 하는 용도라면 isInterrupted() 를 사용
• 직접 체크해서 사용할 때는 Thread.interrupted() 사용
• Thread.interrupted()
  • 스레드가 인터럽트 상태라면 true를 반환하고, 해당 스레드의 인터럽트 상태를 false 로 변경
  • 스레드가 인터럽트 상태가 아니라면 false 를 반환하고, 해당 스레드의 인터럽트 상태를 변경하지 않는다.

package thread.control.interrupt;

import static util.MyLogger.log;
import static util.ThreadUtils.sleep;

public class ThreadStopMainV4 {

    public static void main(String[] args) {
        MyTask task = new MyTask();
        Thread thread = new Thread(task, "work");
        thread.start();

        sleep(100); // 시간을 줄임
        log("작업 중단 지시 thread.interrupt()");
        thread.interrupt();
        log("work 스레드 인터럽트 상태1 = " + thread.isInterrupted());
    }

    static class MyTask implements Runnable {

        @Override
        public void run() {
            while (!Thread.interrupted()) { // 인터럽트 상태 변경O
                log("작업 중");
            }
            log("work 스레드 인터럽트 상태2 = " + Thread.currentThread().isInterrupted());

            try {
                log("자원 정리");
                Thread.sleep(1000);
                log("자원 종료");
            } catch (InterruptedException e) {
                log("자원 정리 실패 - 자원 정리 중 인터럽트 발생");
                log("work 스레드 인터럽트 상태3 = " + Thread.currentThread().isInterrupted());
            }
            log("작업 종료");
        }
    }
}

00:05:50.462 [     work] 작업 중
00:05:50.472 [     work] 작업 중
00:05:50.473 [     work] 작업 중
00:05:50.473 [     work] 작업 중
00:05:50.473 [     work] 작업 중
00:05:50.472 [     main] 작업 중단 지시 thread.interrupt()
00:05:50.474 [     work] 작업 중
00:05:50.486 [     work] work 스레드 인터럽트 상태2 = false
00:05:50.486 [     work] 자원 정리
00:05:50.487 [     main] work 스레드 인터럽트 상태1 = true
00:05:51.490 [     work] 자원 종료
00:05:51.491 [     work] 작업 종료

• 주요 실행 순서
  • main 스레드는 interrupt() 메서드를 사용해서, work 스레드에 인터럽트를 건다.
  • work 스레드는 인터럽트 상태이다. Thread.interrupted()의 결과는 true가 된다.
  • Thread.interrupted()는 이때 work 스레드의 인터럽트 상태를 정상(false)으로 변경한다.
  • 이 때 다음과 같이 while 조건이 false 가 되면서 while 문을 탈출한다.
    • while (!Thread.interrupted())
    • while (!true)
    • while (false)
• Thread.interrupted()를 호출했을 때 스레드가 인터럽트 상태(true)라면 true를 반환하고, 해당 스레드의 인터럽트 상태를 false 로 변경한다.
• 결과적으로 while 문을 탈출하는 시점에 스레드의 인터럽트 상태도 false 로 변경된다.
• work 스레드는 이후에 자원을 정리하는 코드를 실행하는데, 이 때 인터럽트의 상태는 false 이므로 인터럽트가 발생하는 sleep()과 같은 코드를 수행해도 인터럽트가 발생하지 않는다. 이후에 자원을 정상적으로 잘 정리하는 것을 확인할 수 있다.
• 자바는 인터럽트 예외가 한 번 발생하면 스레드의 인터럽트 상태를 다시 정상(false)으로 돌린다. 스레드의 인터럽트 상태를 정상으로 돌리지 않으면 이후에도 계속 인터럽트가 발생하게 된다. ⇒ 인터럽트의 목적을 달성하면 인터럽트 상태를 다시 정상으로 돌려두어야한다.

cf. 물론 꼭 이것만이 정답은 아니다. 예를들어 너무 긴급한 상황이어서 자원을 정리하지 않고 최대한 빨리 스레드를 종료해야한다면 해당 스레드를 다시 인터럽트 상태로 변경하는 것도 방법이다.