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

[manijang2]

join - 시작

1. 코드

package thread.control.join;

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

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("작업 시작");
            ThreadUtils.sleep(2000);
            log("작업 완료");
        }
    }
}

00:11:59 [     main] Start
00:11:59 [ thread-1] 작업 시작
00:11:59 [ thread-2] 작업 시작
00:11:59 [     main] end
00:12:01 [ thread-2] 작업 완료
00:12:01 [ thread-1] 작업 완료

• 위 예제에서 thread-1과 thread-2는 각각 2초간의 작업을 수행하고 종료된다.
• 하지만 메인 스레드는 두 스레드의 작업이 끝나길 기다리지 않고 start() 메서드를 호출한 직후 바로 다음 코드를 실행한다.
• 따라서 로그에서 보이듯이 main 스레드는 "end"를 먼저 출력하고 종료되며, 이후에 thread-1, thread-2가 자신의 작업을 마친다.
• 이렇게 스레드가 동시에 실행되면, 메인 스레드가 다른 스레드보다 먼저 종료될 수 있다.

---

join-필요한 상황

1. 코드

package thread.control.join;

import util.ThreadUtils;

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");
    }

    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);
        }
    }
}

• main 스레드는 thread-1과 thread-2의 작업을 시작(start())시킨 직후, 두 스레드가 계산을 완료하기도 전에 task1.result와 task2.result 값을 바로 출력한다.
• 이 시점에서 두 작업 스레드는 아직 run() 메서드 내부의 연산을 수행 중이므로, result 필드는 여전히 초기값인 0을 유지하고 있다.
• 따라서 콘솔 출력에서 보이듯이 task1.result, task2.result, task1 + task2 모두 0으로 출력된다.

00:32:26 [     main] Start
00:32:26 [ thread-1] 작업 시작
00:32:26 [ thread-2] 작업 시작
00:32:26 [     main] task1.result = 0
00:32:26 [     main] task2.result = 0
00:32:26 [     main] task1 + task2 = 0
00:32:26 [     main] end
00:32:28 [ thread-1] 작업 완료 result = 1275
00:32:28 [ thread-2] 작업 완료 result = 3775

• 즉, 스레드 간 실행 시점이 동기화되지 않아 발생하는 논리적 오류이다.
• 스레드의 작업이 완료되기 전에 결과를 조회하는 동기화 타이밍 문제가 존재한다.
• main 스레드가 두 작업 스레드의 종료를 기다리지 않으므로, 계산 결과(result)를 보장받을 수 없다.

2.this

• 스레드가 run() 메서드를 호출할 때, 해당 메서드를 포함한 객체의 참조를 스택 프레임의 this 변수에 저장한다.
• 스레드가 메서드 내부에서 필드나 다른 메서드에 접근할 때,항상 this 값을 참조하여 자신이 속한 객체의 멤버를 찾아간다.
• 즉, 각 스레드는 자신이 실행 중인 SumTask 인스턴스를 this로 참조하며, 이를 통해 해당 인스턴스의 result 필드에 값을 저장하게 된다.

---

join - sleep() 사용

1. 코드

package thread.control.join;

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

public class JoinMainV2 {

    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("main 스레드 sleep()");
        sleep(3000);
        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);
        }
    }
}

• main스레드에서 sleep(3000)메서드를 통하여 3초간 대기한다.

01:36:13 [     main] Start
01:36:13 [     main] main 스레드 sleep()
01:36:13 [ thread-1] 작업 시작
01:36:13 [ thread-2] 작업 시작
01:36:15 [ thread-2] 작업 완료 result = 3775
01:36:15 [ thread-1] 작업 완료 result = 1275
01:36:16 [     main] main 스레드 깨어남
01:36:16 [     main] task1.result = 1275
01:36:16 [     main] task2.result = 3775
01:36:16 [     main] task1 + task2 = 5050
01:36:16 [     main] end

• 스레드의 작업 시간이 항상 동일하지 않으므로, sleep()으로 타이밍을 맞추는 것은 불안정한 방식이다.
• CPU 스케줄링, 시스템 부하, 쓰레드 수 등 환경 요인에 따라 작업 시간이 달라질 수 있다.
• 만약 스레드가 3초보다 오래 걸린다면 main 스레드는 결과가 완전히 나오기 전에 합산을 수행할 위험이 있다.

while(thread.getState() != TERMINATED) {
    // ...
}

• 하지만 위 방법은 바쁜 대기(busy waiting) 방식으로, CPU 자원을 계속 소모하므로 매우 비효율적이다.

---

join - join() 사용

1. 코드

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);
        }
    }
}

23:55:09 [     main] Start
23:55:09 [     main] join() - main 스레드가 thread1, thread2 종료까지 대기
23:55:09 [ thread-1] 작업 시작
23:55:09 [ thread-2] 작업 시작
23:55:11 [ thread-1] 작업 완료 result = 1275
23:55:11 [ thread-2] 작업 완료 result = 3775
23:55:11 [     main] main 스레드 대기 완료
23:55:11 [     main] task1.result = 1275
23:55:11 [     main] task2.result = 3775
23:55:11 [     main] task1 + task2 = 5050
23:55:11 [     main] end

• 코드는 두 개의 작업을 개별 스레드로 실행한 뒤, join()을 이용하여 main스레드가 두 스레드의 종료를 기다리도록 구성되어 있다.
• 실행 결과를 보면 각 스레드의 작업이 정상적으로 완료된 후 결과가 출력되며, 두 스레드의 작업 합계가 올바르게 계산되었다는 점에서 join()의 동작이 제대로 수행된 것을 확인할 수 있다.

2. join() 호출 시 스레드 변화

1) main 스레드 대기 과정

• thread1.join()과 thread2.join()이 호출되면 main스레드는 해당 스레드가 종료될 때까지 내부적으로 WAITING 상태로 전환된다.
• 두 스레드의 계산 작업은 각각 별도의 실행 흐름에서 진행되며, main스레드는 두 작업이 끝날 때까지 진입할 수 없는 대기 상태로 머무른다.

2) Waiting 상태 진입

• join()은 내부적으로 모니터 락을 통해 스레드 객체를 기반으로 기다리는 구조를 가진다.
• 따라서 main스레드는 스스로 실행을 멈추고 목표 스레드가 TERMINATED 상태가 될 때까지 차단된 상태로 머문다.

3) join() 사용 장점

a. 스레드 간의 결과 수집

• 여러 스레드가 동시에 작업을 수행할 때, 해당 작업들이 완료된 후 그 결과를 이용해야 하는 경우가 자주 존재한다.
• join()은 이러한 작업의 완료 시점을 확실하게 보장해 주어, 스레드 간의 동기화를 매우 단순하고 명확하게 구현할 수 있게 한다.

b. 스레드 흐름 제어

• main스레드가 종료되기 전에 하위 작업 스레드들이 반드시 모두 끝나야 한다면 join()을 이용하는 것이 안전한 선택이다.
• 이 방식은 스레드들의 생명주기 관리에도 자연스럽게 활용된다.

4) join() 단점

• join()은 기본적으로 종료 시점까지 무기한 기다리는 형태로 동작한다.
• 만약 대상 스레드가 예외 발생, 교착 상태, 무한 루프 등으로 종료되지 않는다면, main스레드는 영원히 깨어나지 못한다.
• 이러한 동작은 프로그램 전체가 멈추는 결과로 이어질 수 있으며, 시스템 전체 안정성을 떨어뜨릴 위험이 존재한다.

---

join - 특정 시간 만큼만 대기

1. join()

• join() 메서드는 호출한 스레드가 대상 스레드의 실행이 끝날 때까지 무기한으로 대기한다.
• join(ms) 메서드는 호출한 스레드가 특정 시간 동안만 대상 스레드를 기다리며, 지정된 시간이 지나면 자동으로 RUNNABLE 상태로 돌아와 이후 코드를 계속 실행한다.
• 이러한 동작을 통해 스레드 간의 실행 흐름을 제어할 수 있으며, 특히 작업 시간이 예측되지 않을 때 유용하게 사용된다.

1. 코드

package thread.control.join;

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

public class JoinMainV4 {

   public static void main(String[] args) throws InterruptedException {
       log("Start");

       SumTask task1 = new SumTask(1, 50);

       Thread thread1 = new Thread(task1, "thread-1");
       thread1.start();

       log("join(1000) - main 스레드가 thread1 종료까지 1초 대기");
       thread1.join(1000);
       log("main 스레드 대기 완료");

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

   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:34:42 [     main] Start
00:34:42 [     main] join(1000) - main 스레드가 thread1 종료까지 1초 대기
00:34:42 [ thread-1] 작업 시작
00:34:43 [     main] main 스레드 대기 완료
00:34:43 [     main] task1.result = 0
00:34:44 [ thread-1] 작업 완료 result = 1275

• thread1.join(1000)으로 메인 스레드는 정확히 1초 동안만 대기한다.
• 대기 시간이 끝나면 task1.result는 아직 계산되지 않았으므로 0으로 출력된다.
• 이후에도 thread-1은 백그라운드에서 계속 실행되어 계산을 마친 뒤 결과를 로그로 출력한다.

2. 스레드 상태

• join(ms)를 호출하면 메인 스레드는 일반적인 WAITING 상태가 아니라, 일정 시간 동안만 기다리는 TIMED_WAITING 상태로 전환된다.
• thread-1의 실제 작업 시간은 2초가 필요하지만, 메인 스레드는 1초만 기다리도록 설정되어 있기 때문에, 메인 스레드는 계산 결과를 기다리지 않고 그대로 다음 코드를 실행한다.
• 이런 특성 때문에 task1.result는 계산 완료 전에 출력되므로 0으로 나타나며, 이후 thread-1이 작업을 마치면서 최종 결과를 출력하게 된다.