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

[ilikeram]

📌  join()

package thread.control.join;

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

public class JoinMainV0 {

    public static void main(String[] args) {
        log("Start");
        Thread thread1 = new Thread(new Job(), "thread-1");
        Thread thread2 = new Thread(new Job(), "thread-2");

        thread1.start();
        thread2.start();
        log("End");
    }

    static class Job implements Runnable {

        @Override
        public void run() {
            log("작업 시작");
            sleep(2000);
            log("작업 완료");
        }
    }
}

00:50:23.670 [     main] Start
00:50:23.677 [ thread-1] 작업 시작
00:50:23.678 [     main] End
00:50:23.677 [ thread-2] 작업 시작
00:50:25.681 [ thread-1] 작업 완료
00:50:25.681 [ thread-2] 작업 완료

• main 스레드는 thread-1, thread-2를 실행하고 바로 자신의 다음 코드 실행

       ⇒ main 스레드가 thread-1, thread-2가 끝날때까지 기다리지 않는다.
  

📌  join이 필요한 상황

package thread.control.join;

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

public class JoinMainV1 {

    public static void main(String[] args) {
        log("Start");
        SumTask task1 = new SumTask(1, 50);
        SumTask task2 = new SumTask(51, 100);
        Thread thread1 = new Thread(task1, "thread-1");
        Thread thread2 = new Thread(task2, "thread-2");

        thread1.start();
        thread2.start();

        log("task1.result = " + task1.result);
        log("task2.result = " + task2.result);

        int sumAll = task1.result + task2.result;
        log("task1 + task2 = "+ sumAll);
        log("End");
    }
		
		// SumTask => 계산의 시작값, 종료값을 가진다.
    static class SumTask implements Runnable {

        int startValue;
        int endValue;
        int result = 0;

        public SumTask(int startValue, int endValue) {
            this.startValue = startValue;
            this.endValue = endValue;
        }

        @Override
        public void run() {
            log("작업 시작");
            sleep(2000); // 2초 후에 계산 시작
            int sum = 0;
            for (int i = startValue; i <= endValue; i++) {
                sum += i;
            }
            result = sum; // 계산이 끝나면 결과를 result에 담는다.
            log("작업 완료 result = " + result);
        }
    }
}

00:57:45.247 [     main] Start
00:57:45.255 [ thread-1] 작업 시작
00:57:45.256 [ thread-2] 작업 시작
00:57:45.266 [     main] task1.result = 0
00:57:45.267 [     main] task2.result = 0
00:57:45.268 [     main] task1 + task2 = 0
00:57:45.268 [     main] End
00:57:47.263 [ thread-1] 작업 완료 result = 1275
00:57:47.263 [ thread-2] 작업 완료 result = 3775

• main 스레드는 thread-1, thread-2에 작업 지시하고, 계산이 끝나기 전에 먼저 계산결과를 조회

메모리구조

• 프로그램이 처음 시작되면 main 스레드는 thread-1, thread-2를 생성하고, start()로 실행
• thread-1, thread-2 는 각각 자신에게 전달된 SumTask인스턴스의 run()메서드를 스택에 올리고 실행

• main 스레드는 두 스레드를 시작한 다음에 바로 task1.result, task2.result를 통해 인스턴스에 있는 결과값을 조회 ⇒ main 스레드가 실행한 start()메서드는 스레드의 실행이 끝날때까지 기다리지 않는다.
• thread-1, thread-2 가 계산을 완료해서 result 에 연산결과를 담을때까지는 약 2초정도의 시간이 걸리는데, main 스레드는 계산이 끝나기 전에 result 결과를 조회해서 ‘0’ 이 출력

• 2초가 지난 이후에 thread-1, thread-2는 계산완료 → 이미 main 스레드는 자신의 코드를 모두 실행하고 종료 상태

cf. this?

호출된 인스턴스 메서드가 소속된 객체를 가리키는 참조이며, 스택 프레임 내부에 저장되어있다.
메서드를 호출하면 어떤 인스턴스의 메서드를 호출했는지 기억하기 위해 참조값을 스택프레임 내부에 저장 → 특정 메서드안에서 this 호출 시 바로 스택프레임 안에 있는 this 값을 불러와서 사용

• 특정 스레드를 기다리는 가장 간단한 방법 → sleep();

  • thread-1, thread-2는 계산에 2초 정도의 시간이 걸린다는 것을 알고 있으므로 main 스레드가 약 3초후에 계산결과를 조회하도록 설정

  • 그러나 sleep()을 사용해서 기다리는 방법은 대기시간에 손해도 보고, thread-1, thread-2의 수행시간이 달라지는 경우 정확한 타이밍을 맞추기가 어려움

  • 더 좋은 방법은 thread-1, thread-2가 계산을 끝내고 종료될 때까지 main 스레드가 기다리는 방법

    while(thread.getState() != TERMINATED){
    	// 스레드의 상태가 종료될 때까지 계속 반복
    }
    // 계산결과 출력

  • 이런 방법은 번거롭고 계속되는 반복문은 CPU연산을 사용 => join 메서드 사용으로 해결

• join() : 호출 스레드는 대상 스레드가 완료될 때까지 무한정 대기

  package thread.control.join;
  
  import static util.MyLogger.log;
  import static util.ThreadUtils.sleep;
  
  public class JoinMainV3 {
  
      public static void main(String[] args) throws InterruptedException {
          log("Start");
          SumTask task1 = new SumTask(1, 50);
          SumTask task2 = new SumTask(51, 100);
          Thread thread1 = new Thread(task1, "thread-1");
          Thread thread2 = new Thread(task2, "thread-2");
  
          thread1.start();
          thread2.start();
  
          // 스레드가 종료될 때 까지 대기
          log("join() - main 스레드가 thread1, thread2 종료까지 대기");
          thread1.join();
          thread2.join();
          log("main 스레드 대기 완료");
  
          log("task1.result = " + task1.result);
          log("task2.result = " + task2.result);
  
          int sumAll = task1.result + task2.result;
          log("task1 + task2 = "+ sumAll);
          log("End");
      }
  
      static class SumTask implements Runnable {
  
          int startValue;
          int endValue;
          int result = 0;
  
          public SumTask(int startValue, int endValue) {
              this.startValue = startValue;
              this.endValue = endValue;
          }
  
          @Override
          public void run() {
              log("작업 시작");
              sleep(2000);
              int sum = 0;
              for (int i = startValue; i <= endValue; i++) {
                  sum += i;
              }
              result = sum;
              log("작업 완료 result = " + result);
          }
      }
  }

  00:56:43.571 [     main] Start
  00:56:43.584 [ thread-1] 작업 시작
  00:56:43.585 [ thread-2] 작업 시작
  00:56:43.586 [     main] join() - main 스레드가 thread1, thread2 종료까지 대기
  00:56:45.595 [ thread-2] 작업 완료 result = 3775
  00:56:45.595 [ thread-1] 작업 완료 result = 1275
  00:56:45.596 [     main] main 스레드 대기 완료
  00:56:45.599 [     main] task1.result = 1275
  00:56:45.599 [     main] task2.result = 3775
  00:56:45.600 [     main] task1 + task2 = 5050
  00:56:45.600 [     main] End

  • main 스레드에서 thread1.join();, thread2.join(); 코드를 실행하게 되면 main 스레드는 thread-1, thread-2가 종료될 때까지 기다린다. ⇒ main 스레드는 WAITING 상태
  • thread-1 이 종료되지 않았다면, main 스레드는 thread1.join()코드 안에서 더는 진행하지 않고 멈추고, thread-1 이 종료되면 main 스레드는 RUNNABLE 상태가 되고 다음 코드로 이동한다.
  • 동일하게 thread-2이 아직 종료되지않았으면 main 스레드는 진행하지 않고 멈추어 기다린 후 thread-2가 종료되면 main 스레드는 RUNNABLE 상태가 되고 다음 코드로 이동
  • 이 경우에는 thread-1이 종료되는 시점에 thread-2도 거의 같이 종료되기 떄문에 thread2.join()은 대기하지 않고 바로 빠져나온다.
  • 특정 스레드가 완료될 때까지 기다려야하는 상황이라면 join()을 사용하면 된다. 그러나 다른 스레드가 완료될때까지 무기한 기다리는 단점이 있다.

  cf. Waiting(대기상태) : 스레드가 다른 스레드의 특정 작업이 완료되기를 무기한 기다리는 상태이며, join()을 호출하는 스레드는 대상 스레드가 TERMINATED 상태가 될 때까지 대기한다. 대상 스레드가 TERMINATED 상태가 되면 호출 스레드는 다시 RUNNABLE 상태가 되면서 다음 코드 수행

• join(ms) : 호출 스레드는 특정 시간만큼만 대기, 호출 스레드는 지정한 시간이 지나면 다시 RUNNABLE 상태가 되면서 다음 코드를 수행

  thread1.join(1000); // main 스레드는 thread-1을 1초간 기다린다.

  • 이때 main 스레드의 상태는 WAITING 이 아닌 TIMED_WAITING (보통 무기한 대기하면 WAITING 상태, 특정 시간만큼만 대기하는 경우 TIMED_WAITING 상태
  • thread-1의 작업은 2초가 걸린다. 1초가 지나도 thread-1의 작업이 완료되지 않으므로, main 스레드는 대기를 중단하고 RUNNABLE 상태로 바뀌면서 다음코드 수행 ⇒ 이때 thread-1의 작업이 아직 완료되지 않았기 때문에 task1.result = 0이 출력
  • main 스레드 종료이후 thread-1이 계산을 끝내므로 작업완료 result = 1275 출력

• 다른 스레드가 끝날때까지 무한정 기다려야한다면 join()을 사용하고, 다른 스레드의 작업을 무한정 기다릴 수 없다면 join(ms)를 사용