[JAVA] 스레드 Join

JAVA

[JAVA] 스레드 Join

경딩 2024. 11. 12. 20:59

스레드는 생성하고 시작하고, 종료되는 생명주기를 가진다.

스레드의 상태

New (새로운 상태) : 스레드가 생성되었으나 아직 시작되지 않은 상태
Runnable (실행 가능 상태) : 스레드가 실행 중이거나 실행될 준비가 된 상태
Blocked (차단 상태) : 스레드가 동기화 락을 기다리는 상태
Waiting (대기 상태) : 스레드가 무한으로 다른 스레드의 작업을 기다리는 상태
Time Waiting (시간제한 대기 상태): 스레드가 일정 시간 동안 다른 스레드의 작업을 기다리는 상태
Terminated (종료 상태) : 스레드의 실행이 완료된 상태.

자바 스레드(Thread) 의 생명주기는 여러 상태(state)로 나뉘며, 각 상태는 스레드가 실행되고 종료되기까지의 과정을 나타낸다. 자바 스레드의 생명주기를 자세히 알아보자.

New (새로운 상태) :
1. 스레드가 생성되었으나 아직 시작되지 않은 상태
2. 이 상태에서는 Thread 객체가 생성되지만 start() 메서드가 호출되지 않은 상태이다.
3. 예: Thread thread = new Thread(runnable);
Runnable (실행 가능 상태) : 스레드가 실행 중이거나 실행 될 준비가 된 상태
1. 스레드가 실행될 준비가 된 상태이다. 이 상태에서 스레드는 실제로 CPU에서 실행될 수 있다.
2. start() 메서드가 호출되면 스레드는 이 상태로 들어간다.
3. 예: thread.start();
4. 이 상태는 스레드가 실행될 준비가 되어 있음을 나타내며, 실제로 CPU에서 실행될 수 있는 상태이다. 그러나 Runnable 상태에 있는 모든 스레드가 동시에 실행되는 것은 아니다. 운영체제의 스케줄러가 각 스레드에 CPU 시간을 할당하여 실행하기 때문에 Runnable 상태에 있는 스레드는 스케줄러의 실행 대기열에 포함되어 있다가 차례로 CPU에서 실행된다.
5. 참고로 운영체제 스케줄러의 실행 대기열에 있든, CPU 에서 실제 실행되고 있든 모두 RUNNABLE 상태이다. 자바에서 이 둘을 구분해서 확인할 수 없다.
6. 보통 이걸 실행상태라고 부른다.
Blocked (차단 상태)
1. 스레드가 다른 스레드에 의해 동기화 락을 얻기 위해 기다리는 상태
2. 예를 들어, synchronized 블록에 진입하기 위해 락을 얻어야 하는 경우 이 상태로 들어간다.
3. 예: synchronized (lock) { ...} 코드 블록에 진입하려고 할 때, 다른 스레드가 이미 lock의 락을 가지고 있는 경우
Waiting (대기 상태)
1. 스레드가 다른 스레드의 특정 작업이 완료되기를 무기한 기다리는 상태
2. wait(), join() 메서드가 호출될 때 이 상태가 된다.
3. 스레드는 다른 스레드가 notify() 또는 notifyAll() 메서드를 호출하거나, join() 이 완료될 때까지 기다린다.
4. 예 : object.wait();
Time Waiting (시간 제한 대기 상태)
1. 스레드가 일정 시간 동안 다른 스레드의 작업을 기다리는 상태
2. sleep(long millis) , wait(long timeout) , join(long millis) 메서드가 호출될 때 이 상태가 된다.
3. 주어진 시간이 경과하거나 다른 스레드가 해당 스레드를 깨우면 이 상태에서 벗어난다.
4. 예 : Thread.sleep(10000);
Terminated (종료 상태) :
1. 스레드의 실행이 완료된 상태
2. 스레드가 정상적으로 종료되거나, 예외가 발생하여 종료된 경우 이 상태로 들어간다.
3. 스레드는 한번 종료되면 다시 시작할 수 없다.

자바 스레드의 상태 전이 과정

New → Runnable : start() 메서드를 호출하면 스레드가 Runnable 상태로 전이된다.
Runnable → Blocked/ Waiting/ Time Waiting : 스레드가 락을 얻지 못하거나, wait() 또는 sleep() 메서드를 호출할 때 해당 상태로 전이된다.
Blocked/Waiting/Time Waiting → Runnable : 스레드가 락을 얻거나, 기다림이 완료되면 다시 Runnable 상태로 돌아간다.
Runnable → Terminated : 스레드의 run() 메서드가 완료되면 스레드는 Terminated 상태가 된다.

스레드의 생명주기 - 코드

스레드 생명 주기 코드를 확인해보자! 스레드가 생성, 실행, 대기 및 종료 상태로 변할 때마다 해당 상태를 로그로 출력한다.

이를 통해 스레드의 생명주기를 이해해보자.

package thread.control;

import static util.MyLogger.log;

public class ThreadStateMain {
    public static void main(String[] args) throws InterruptedException {



        // myThread 스레드
        Thread myThread = new Thread(new HelloRunnable(), "myThread" );
        log(" myThread.getState 1 " + myThread.getState()); // NEW
        log(" myThread.start ");
        myThread.start();
        Thread.sleep(1000);
        log(" myThread.getState 3 " + myThread.getState()); // TIME_WAITING
        Thread.sleep(4000);
        log(" myThread.getState 5 " + myThread.getState()); //TERMINATE
        log(" end ");
    }

    public static class HelloRunnable implements Runnable{
        @Override
        public void run() {
            try {
                log(" start ");
                log(" myThread.getState 2 " + Thread.currentThread().getState()); //RUNNABLE
                log(" sleep start() start");
                Thread.sleep(3000);
                log(" myThread.getState 4 " + Thread.currentThread().getState()); //RUNNABLE
                log(" sleep start() end");
                log(" end ");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(Thread.currentThread().getName() + " run() ");
        }
    }
}

Thread.currentThread()를 호출하면 해당 코드를 실행하는 스레드 객체를 조회할 수 있다.
Thread.sleep() : 해당 코드를 호출한 스레드는 TIMED_WAITING 상태가 되면서 특정 시간만큼 대기한다.
시간은 밀리초(ms) 단위이다. 1밀리 초 = 1/1000초, 1000 밀리초 = 1초이다.
Thread.sleep() 은 InterruptedException이라는 체크예외를 던진다. 따라서 체크 예외를 잡아서 처리하거나 던져야 한다.

state1 = NEW
- main 스레드를 통해 myThread 객체를 생성한다. 스레드 객체만 생성하고 아직 start()를 호출하지 않았기 때문에 NEW 상태이다.
state2 = RUNNABLE
- myThread.start()를 호출해서 myThread을 실행 상태로 만든다. 따라서 RUNNABLE 상태가 된다.
- 참고로 실행 상태가 너무 빨리 지나가기 때문에 main 스레드에서 myThread의
- 대신에 자기 자신이 myThread에서 실행 중인 자신의 상태를 확인했다.
state3 = TIMED_WAITING
- Thread.sleep(3000) : 해당 코드를 호출한 스레드는 3000ms (3초) 간 대기한다. myThread 가 해당 코드를 호출했으므로 3초간 대기하면서 TIMED_WAITING 상태로 변한다.
- 참고로 이때 mian 스레드가 myThread의 TIMED_WAITING 상태를 확인하기 위해 1초간 대기하고 상태를 확인했다.
- state4 = RUNNABLE
- myThread는 3초 대기시간 후 TIMED_WAITING 상태에서 빠져나와 다시 실행될 수 있는 RUNNABLE 상태로 바뀐다.
state5 = TERMINATED
- myThread 가 run() 메서드를 실행 종료하고 TERMINATED 상태가 된다.
- myThread 입장에서 run() 이 스택에 남은 마지막 메서드인데, run()까지 실행되고 나면 스택이 완전히 비워진다. 이렇게 스택이 비워지면 해당 스택을 사용하는 스레드도 종료된다.

실행 결과

실행 상태 그림 - main 스레드포함

체크 예외 재정의

Runnable 인터페이스의 ` run() ` 메서드를 구현할 때 InterruptedException 체크 예외를 밖으로 던질 수 없는 이유는 뭘까?

public interface Runnable {
    /**
     * Runs this operation.
     */
    void run();
}

자바에서 메서드를 재정의 할 때, 재정의 메서드가 지켜야 할 예외와 관련된 규칙이 있다.

체크 예외

부모 메서드가 체크 예외를 던지지 않는 경우, 재정의된 자식 메서드도 체크 예외를 던질 수 없다.
자식 메서드는 부모 메서드가 던질 수 있는 체크 예외의 하위 타입만 던질 수 있다.

언체크(런타임) 예외

예외 처리를 강제하지 않으므로 상관없이 던질 수 있다

Runnable run() 인터페이스의 ` run() ` 메서드는 아무런 체크 예외를 던지지 않는다. 따라서 Runnable 인터페이스의 run() 메서드를 재정의 하는 곳에서는 체크예외를 밖으로 던질 수 없다.

public class CheckedExceptionMain {
    public static void main(String[] args) throws Exception {
        throw new Exception();
    }

    static class CheckedRunnable implements Runnable {
        @Override
        public void run() /*throws Exception*/ { // 주석 풀면 예외 발생
            //throw new Exception(); // 주석 풀면 예외 발생
        }
    }
}

main() 은 체크 예외를 밖으로 던질 수 있다.
run() 은 체크 예외를 밖으로 던질 수 없다.

예를 들어 다음 코드의 InterruptedException 도 체크 예외이므로 던질 수 없다. 컴파일 오류가 발생한다.

자바는 왜 이런 제약을 두는 것일까?

부모 클래스의 메서드를 호출하는 클라이언트 코드는 부모메서드가 던지는 특정 예외만을 처리하도록 작성된다. 자식 클래스가 더 넓은 범위의 예외를 던지면 해당 코드는 모든 예외를 제대로 처리하지 못할 수 있다. 이는 예외 처리의 일관성을 해지고, 예상하지 못한 런타임 오류를 초래할 수 있다.

자바 컴파일러는 Parent p의 method()를 호출한 것으로 인지한다.

Parent p는 InterruptedException를 반환하는데, 그 자식의 전혀 다른 예외를 반환한다마 클라이언트는 해당 예외를 잡을 수 없다. 이것은 확실하게 모든 예외를 체크하는 체크예외의 규약에 맞지 않는다.

따라서 자바에서 체크 예외의 메서드 재정의는 다음과 같은 규칙을 가진다.

체크 예외 재정의 규칙

자식 클래스에 재정의된 메서드는 부모메서드가 던질 수 있는 체크 예외의 하위 타입만 던질 수 있다.
원래 메서드가 체크 예외를 던지지 않는 경우, 재정의된 메서드도 체크 예외를 던질 수 없다.

체크 예외를 run() ` 메서드에서 던질 수 없도록 강제함으로써, 개발자는 반드시 체크 예외를 try-catch 블록 내에서 처리하게 된다. 이는 예외 발생 시 예외가 적절히 처리되지 않아서 프로그램이 비정상 종료되는 상황을 방지할 수 있다. 특히 멀티스레딩 환경에서는 예외 처리를 강제함으로써 스레드의 안정성과 일관성을 유지할 수 있다.

https://newfangled.tistory.com/51

[JAVA] Error 와 Exception

예외 클래스의 계층 구조자바에서는 실행 시 발생할 수 있는 오류 (Excepton과 Error)를 클래스로 정의하였다.모든 클래스의 조상인 Object 클래스가 최상단에 있고 Exception과 Error 클래스의 자손이

newfangled.tistory.com

join - 시작

앞서 Thread.sleep() 메서드를 통해 TIMED_WAITTING 상태를 알아보았다. 이번에는 join() 메서드를 통해 WAITTING(대기 상태)가 무엇이고 왜 필요한지 알아보자.

Waiting (대기 상태)

스레드가 다른 스레드의 특정 작업이 완료되기를 무기한 기다리는 상태

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(), "tread-1");
        Thread thread2 = new Thread(new Job(), "tread-2");

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

        log("End");
    }

    static class Job implements Runnable {

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

스레드의 실행 순서는 보장되지않기 때문에 실행 결과는 약간 다를 수 있다.

그림에서는 생략했지만, thread-2 도 main 스레드가 생성하고 start() 를 호출해서 실행한다.

thread-1 , thread-2는 각각 특정 작업을 수행한다. 작업 수행에 약 2초 정도가 걸린다고 가정하기 위해 sleep()을 사용해서 2초간 대기한다. (그림에서는 RUNNABLE로 표현했지만 , 실제로는 TIMED_WAITING 상태이다.)

실행 결과를 보면 main 스레드가 먼저 종료되고, 그다음에 thread-1 , thread-2 가 종료된다.

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

여기서 핵심은 thread-1 , thread-2 가 끝날까지 기다리지 않는다는 점이다. main 스레드는 단지 start()를 호출해서 다른 스레드를 실행만 하고 바로 자신의 다음 코드를 실행한다.

그런데 만약 thread-1 , thread-2 가 종료된 다음에 main 스레드를 가장 마지막에 종료하려면 어떻게 해야 할까? 예를 들어서 main 스레드가 thread-1 , thread-2 에 각각 어떤 작업을 지시하고, 그 결과를 받아서 처리하고 싶다 면 어떻게 해야할까?

join - 필요한 상황

1~100까지 더하는 간단한 코드를 작성해 보자.

int sum = 0;
for (int i = 1; i <= 100; i++) {
 sum += i;
}

이 코드는 스레드를 하나만 사용하기 때문에 CPU 코어도 하나만 사용할 수 있다. CPU 코어를 더 효율적으로 사용하려면 여러 스레드로 나누어 계산하면 된다.

main 스레드가 1 ~ 100으로 더하는 작업을 thread-1 , thread-2에 각각 작업을 나누어 지시하면 CPU 코어를 더 효율적으로 활용할 수 있다. CPU 코어가 2개라면 이론적으로 연산 속도가 2배 빨라진다.

thread-1 : 1 ~ 50까지 더하기
thread-2 : 51 ~ 100까지 더하기
main : 두 스레드의 계산 결과를 받아서 합치기(이건 간단한 연산 한 번이니 속도 계산에서 제외하자)

package thread.control.join;

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

public class JoinMainV1 {
    public static void main(String[] args) {
        logStart();
        SumTask sumTask1 = new SumTask(1, 50);
        SumTask sumTask2 = new SumTask(51, 100);
        Thread thread1 = new Thread(sumTask1, "thread-1");
        Thread thread2 = new Thread(sumTask2, "thread-2");


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


        log("sumTask1.result : " + sumTask1.result);
        log("sumTask2.result : " + sumTask2.result);
        int sum = sumTask1.result + sumTask2.result;
        log("task1 + task2 = " + sum);
        logEnd();
    }

    static class SumTask implements Runnable {

        int startValue;
        int endValue;
        int result;

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

        @Override
        public void run() {
            logStart();
            sleep(2000);
            int sum = 0;
            for (int i = startValue; i <= endValue; i++) {
                sum += i;
            }
            result = sum;
            log("작업 완료 result : " + result);
            logEnd();
        }
    }
}

main 스레드는 thread-1, thread-2에 작업을 지시하고, thread-1, thread-2 가 계산을 완료하기도 전에 먼저 계산 결과를 조회했다. 참고로 thread-1, thread-2 가 계산을 완료하는데도 2초 정도의 시간이 걸린다.

프로그램이 처음 시작되면 main 스레드는 thread-1, thread-2를 생성하고 start()로 실행한다.
thread-1, thread-2는 각각 자신에게 전달된 SumTask 인스턴스의 run() 메서드를 스택에 올리고 실행한다.
thread-1 은 x001 인스턴스의 run() 메서드를 실행한다.
thread-2 은 x002 인스턴스의 run() 메서드를 실행한다.
main 스레드는 두 스레드를 시작한 다음에 바로 sumTask1.result , sumTask2.result를 통해 인스턴스에 있는 결과 값을 조회한다. 참고로 main 스레드가 실행한 start() 메서드는 스레드의 실행이 끝날 때까지 기다리지 않는다. 다른 스레드를 실행만 해두고, 자신의 다음 코드를 실행할 뿐이다!
thread-1 , thread-2 가 계산을 완료해서 result에 연산 결과를 담을 때까지 약 2초 정도의 시간이 걸린다.
main 스레드는 계산이 끝나기 전에 result의 결과를 조회한 것이다. 따라서 0 값이 출력된다.

2초가 지난 이후 thread-1 , thread-2는 계산을 완료한다.

이때 main 스레드는 이미 자신의 코드를 모두 실행하고 종료된 상태이다.

sumTask1 인스턴스의 result 에는 1275 가 담겨있고, sumTask2 인스턴스의 result 에는 3775 가 담겨있다.

여기서 문제의 핵심은 main 스레드가 thread-1 , thread-2의 계산이 끝날 때까지 기다려야 한다는 점이다.

참고 - this의 비밀

어떤 메서드를 호출하는 것은, 정확히는 특정 스레드가 어떤 메서드를 호출하는 것이다.

스레드는 메서드의 호출을 관리하기 위해 메서드 단위로 스택 프레임을 만들고 해당 스택 프레임을 스택 위에 쌓아 올린다.

이때 인스턴스의 메서드를 호출하면, 어떤 인스턴스의 메서드를 호출했는지 기억하기 위해, 해당 인스턴스의 참조값을 스택 프레임 내부에 저장해 둔다. 이것이 우리가 자주 사용하던 this이다.

특정 메서드 안에서 this를 호출하면 바로 스택프레임 안에 있는 this 값을 불러서 사용하게 된다.

그림을 보면 스택 프레임 안에 this를 확인할 수 있다.

이렇게 this 가 있기 때문에 thread-1 , thread-2는 자신의 인스턴스를 구분해서 사용할 수 있다. 예를 들어서 필드에 접근할 때 this를 생략하면 자동으로 this 를 참고해서 필드에 접근한다.

정리하면 this는 호출된 인스턴스 메서드가 소속된 객체를 가리키는 참조이며. 이것이 스택프레임 내부에 저장되어 있다.

join - sleep 사용

특정 메서드를 기다리게 하는 가장 간단한 방법은 sleep을 사용하는 것이다.

package thread.control.join;

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

public class JoinMainV1 {
    public static void main(String[] args) {
        logStart();
        SumTask sumTask1 = new SumTask(1, 50);
        SumTask sumTask2 = new SumTask(51, 100);
        Thread thread1 = new Thread(sumTask1, "thread-1");
        Thread thread2 = new Thread(sumTask2, "thread-2");


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

        // 정확한 타이밍을 맞추어 기다리기 어려움
        log(" main 스레드 sleep");
        sleep(3000);
        log(" main 스레드 깨어남");

        log("sumTask1.result : " + sumTask1.result);
        log("sumTask2.result : " + sumTask2.result);
        int sum = sumTask1.result + sumTask2.result;
        log("task1 + task2 = " + sum);
        logEnd();
    }

    static class SumTask implements Runnable {

        int startValue;
        int endValue;
        int result;

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

        @Override
        public void run() {
            logStart();
            sleep(2000);
            int sum = 0;
            for (int i = startValue; i <= endValue; i++) {
                sum += i;
            }
            result = sum;
            log("작업 완료 result : " + result);
            logEnd();
        }
    }
}

thread-1 , thread-2는 계산에 2초가 걸린. 따라서 main 스레드가 3초 후 계산 결과를 조회하도록 했다.

하지만 이렇게 sleep을 사용하면 대기 시간을 손해 보고, 스레드들의 수행시간이 달라지는 경우 정확한 타이밍을 맞추기 어렵다.

join - join 사용

package thread.control.join;

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

public class JoinMainV3 {
    public static void main(String[] args) throws InterruptedException {
        logStart();
        SumTask sumTask1 = new SumTask(1, 50);
        SumTask sumTask2 = new SumTask(51, 100);
        Thread thread1 = new Thread(sumTask1, "thread-1");
        Thread thread2 = new Thread(sumTask2, "thread-2");


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


        // 스레드가 종료 될 때까지 대기
        log("join() - main 스레드가 thread1, thread2 종료까지 대기");
        thread1.join();
        thread2.join();
        log("main 스레드 대기 완료");

        log("sumTask1.result : " + sumTask1.result);
        log("sumTask2.result : " + sumTask2.result);
        int sum = sumTask1.result + sumTask2.result;
        log("task1 + task2 = " + sum);
        logEnd();
    }

    static class SumTask implements Runnable {

        int startValue;
        int endValue;
        int result;

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

        @Override
        public void run() {
            logStart();
            sleep(2000);
            int sum = 0;
            for (int i = startValue; i <= endValue; i++) {
                sum += i;
            }
            result = sum;
            log("작업 완료 result : " + result);
            logEnd();
        }
    }
}

main 스레드에서 다음 코드를 실행하게 되면 mian 스레드는 thread-1, thread-2 가 종료될 때까지 기다린다.

이때 main 스레드는 WAITTING 상태가 된다.

        thread1.join();
        thread2.join();

예를 들어서 thread-1 이 아직 종료되지 않았다면 main 스레드는 thread1.join() 코드 안에서 더는 진행하지 않고 멈추어 기다린다. 이후에 thread-1 이 종료되면 main 상태는 RUNNABLE 상태가 되고 다음 코드로 이동한다.

이때 thread-2 가 아직 종료되지 않았다면 main 스레드는 thread2.join() 코드 안에서 진행하지 않고 멈추어 기다린다.

이후에 thread-2 이 종료되면 main 스레드는 RUNNABLE 상태가 되고 다음 코드로 이동한다.

이 경우 thread-1 이 종료되는 시점에 thread-2 도 거의 같이 종료되기 때문에 thread2.join() 은 대기하지 않고 바로 빠져나온다.

Waiting (대기 상태)

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

이렇듯 특정 스레드가 완료될 때까지 기다려야 하는 상황이라면 join() 을 사용하며 된다.

join - 특정 시간만큼만 대기

join() 은 두 가지 메서드가 있다

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

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

package thread.control.join;

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

public class JoinMainV4 {
    public static void main(String[] args) throws InterruptedException {
        logStart();
        SumTask sumTask1 = new SumTask(1, 50);
        Thread thread1 = new Thread(sumTask1, "thread-1");


        thread1.start();


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

        log("sumTask1.result : " + sumTask1.result);
        logEnd();
    }

    static class SumTask implements Runnable {

        int startValue;
        int endValue;
        int result;

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

        @Override
        public void run() {
            logStart();
            sleep(2000);
            int sum = 0;
            for (int i = startValue; i <= endValue; i++) {
                sum += i;
            }
            result = sum;
            log("작업 완료 result : " + result);
            logEnd();
        }
    }
}

별도의 스레드에서 1~50까지 더하고, 그 결과를 조회한다.

join(1000)을 사용해서 1초만 대기한다

실행 결과

main 스레드는 join(1000) 을 사용해서 ` thread-1을 1초만 기다린다.

이때 main 스레드 상태는 WAITING `이 아니라 TIMED_WAITING 이 된다.

보통 무기한 대기하면 WAITING 상태가 되고 특정 시간만큼만 대기하는 경우 TIMED_WAITING 상태가 된다.

thread-1의 작업에는 2초가 걸린다.

1초가 지나도 thread-1 작업이 아직 완료되지 않았기 때문에 sumTask1.result : 0 이 출력된다.

main 스레드가 종료된 이후에 thread-1 계산을 끝낸다. 따라서 작업 완료 result : 1275 이 출력된다.

정리

다른 스레드가 끝날 때까지 무한정 기다려야 한다면 join()을 사용하고, 다른 스레드가 작업을 무한정 기다릴 수 없다면 join(ms)를 사용하면 된다. 물론 기다리다 중간에 나오는 상황인데, 결과가 없다면 추가적인 오류처리가 필요할 수 있다.

'JAVA' 카테고리의 다른 글

[JAVA] 동기화 - synchronized (1)	2024.11.13
[JAVA] 스레드 Interrupted (0)	2024.11.13
[JAVA] Runnable 을 만드는 다양한 방법 (0)	2024.11.11
[JAVA] 데몬 스레드 (0)	2024.11.11
[JAVA] 스레드란? run() start() 의 차이 (0)	2024.11.11

현재글[JAVA] 스레드 Join

뚝딱 뚝딱 개발일기

스프링컨테이너, call by value 와 call by reference, realmysql, 프로그래머스, 다양한 의존관계 주입, 람다식, 정규식, 인프런, Java, 백준 12886, 자바의신11~18, 김영한, 스프링, 백준11049, equals ==, 자바의 신2, chain – matrix multiplication problem, 정리해봅시다, 행렬곱셈순서, 자바,

Today :
Yesterday :

일	월	화	수	목	금	토
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

뚝딱 뚝딱 개발일기