자바 : 스레드(2)

🚀 스레드를 통제하는 메서드들

이번 내용을 알기 위해서는 "스레드의 상태 변화"에 대해서 알고 있어야 깊이 있게 코드를 이해할 수 있을 것이다. 스레드는 프로세서를 함께 사용하고 항상 하나만 실행한다. 또 한 프로세스에 있는 스레드는 순차적으로 실행하고, 해당 스레드의 정보를 저장하는 레지스터와 스택이 있다.

 

스레드의 상태 변화

스레드도 프로세스와 마찬가지로 위와 같이 스레드의 상태 변화가 있다. 스레드의 장점은 스레드 한 개가 대기 상태로 변할 때 전체 프로세스를 대기 상태로 바꾸지 않는다는 것이다. 실행 상태의 스레드가 대기 상태가 되면 다른 스레드를 실행할 수 있다. 그러나 프로세스와 달리 서로 독립적이지는 않다.(프로세스의 메모리를 공유하기 때문에)

좀 더 깊게 알고 싶다면 개인적으로 운영체제에서 "프로세스&스레드" 파트를 공부해보는 것을 추천한다.

 

자바에서 스레드 상태변화에 따른 메서드

Thread.State	getState() :  Returns the state of this thread.
void	join() : Waits for this thread to die.
void	join(long millis) : Waits at most millis milliseconds for this thread to die.
void	join(long millis, int nanos) : Waits at most millis milliseconds plus nanos nanoseconds for this thread to die.
void	interrupt() : Interrupts this thread.

위의 표에 있는 메서드들은 스레드를 통제하는 메서드들이다. 여기서 Thread.State를 살펴보면 "Enum Thread.State" 즉 Enum 클래스이다. 상세 값을 살펴보면 아래와 같이 상수들의 목록이 선언되어 있다. 위의 첨부된 스레드 상태 변화 이미지와 대조하면서 보면 좋을 것이다.

상태	의미
NEW	아직 시작되지 않은 스레드 상태.
RUNNABLE	Java 가상 머신에서 실행 중인 스레드 상태.
BLOCKED	모니터 lock이 풀리기를 기다리면서 스레드 실행 중지 상태
WAITING	스레드가 대기중인 상태
TIMED WAITING	특정 시간만큼 스레드가 대기중인 상태
TERMINATED	스레드가 종료된 상태

예제를 통해 살펴보자.

package com.study;
 
class SleepThread1 extends Thread {
    long sleepTime;
    public SleepThread1(long sleepTime) {
        this.sleepTime = sleepTime;
    }
 
    @Override
    public void run() {
        try {
            System.out.println("Sleeping " + getName());
            Thread.sleep(sleepTime);
            System.out.println("Stopping " + getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
 
// entry point
public class RunThreads {
    public static void main(String[] args) {
        RunThreads sample = new RunThreads();
        sample.checkThreadState();
    }
 
    public void checkThreadState() {
        SleepThread1 thread = new SleepThread1(2000);
        try {
            System.out.println("thread state : " + thread.getState());
            thread.start();
            System.out.println("thread state(after start) : " + thread.getState());
 
            Thread.sleep(1000);
            System.out.println("thread state(after 1 sec) : " + thread.getState());
 
            thread.join();
            thread.interrupt();
            System.out.println("thread state(after join) : " + thread.getState());
 
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

스레드 객체를 생성하기만 했을 때는 NEW이고,
start() 메서드로 실행시키니 RUNNABLE로 바뀌었다.
뭐 자세히 보면 당연한 결과일 것이다.
실제로 돌려봐도 전혀 문제가 없을 것이다.
interrupt() 메서드는 현재 수행 중인 스레드를 중단시킨다. 하지만 join() 메서드 후 스레드는 이미 종료가 되었기 때문에 아무런 영향을 주지 않고 넘어간다.
아래의 이미지처럼 interrupt() 메서드를 위로 올려보고 실행시켜보자.

위와 같이 interrupt 되었다고 예외가 발생한다. 
좀 더 예외를 가지고 알아보자.

package com.study;
 
class SleepThread1 extends Thread {
    long sleepTime;
    public SleepThread1(long sleepTime) {
        this.sleepTime = sleepTime;
    }
 
    @Override
    public void run() {
        try {
            System.out.println("Sleeping " + getName());
            Thread.sleep(sleepTime);
            System.out.println("Stopping " + getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
 
// entry point
public class RunThreads {
    public static void main(String[] args) {
        RunThreads sample = new RunThreads();
        sample.checkJoin();
    }
    public void checkJoin() {
        SleepThread1 thread = new SleepThread1(2000);
        try {
            thread.start();
            thread.join(500);
            thread.interrupt();
            System.out.println("thread state(after join) : " + thread.getState());
        } catch (Exception e) {
            e.printStackTrace();
        }
    } 
}

여기서 SleepThread1 클래스 생성 시 2000 즉 2초를 생성자로 던져주며 시작하게 된다. 그렇게 start()를 통해 스레드가 생성되면 run() 메서드가 실행되고, 2초 대기 중인 상태로 빠진다. 이때 이초를 기다리지만 join(500)으로 0.5초만 기다리다가 다음 코드로 진행이 된다. 0.5초 지나 봤자 run메서드는 1.5초가 남았기에 아직 대기 중인 상태이다 즉 스레드가 끝나지 않았다는 뜻이다. 이 상황에서 interrupt가 발생해서 예외가 발생한 것이다. 그래서 join 메서드의 500을 2020으로 기다리는 초를 늘려준다면 예외가 발생하지 않을 것이다. 스레드의 2초를 기다린 뒤 스레드가 종료되고 인터럽트가 발생되니 아무런 예외가 발생하지 않은 것이다.

 

🎯 Object 클래스에 선언된 스레드와 관련 있는 메서드들

Thread 클래스에 선언된 메서드 외에 스레드의 상태를 통제하는 Object 클래스들에 선언되어 있는 메서드들이 있다. 스레드(1)에서 synchronized에서 "문지기"라는 수식어로 등장했었다. 

리턴 타입	메서드 이름 및 매개 변수	설명
void	wait()	다른 스레드가 Object 객체에 대한 notify() 메서드나 notifyAll() 메서드를 호출할 때까지 현재 스레드가 대기하고 있도록한다.
void	wait(long timeout)	wait() 메서드와 동일한 기능을 제공하며, 매개 변수에 지정한 시간만큼 대기한다. 즉, 매개 변수 시간을 넘어 섰을 때에는 현재 스레드는 다시 깨어난다.
void	wait(long timeout, int nanos)	wait() 메서드와 동일한 기능을 제공한다. 하지만 wait(timeout)에서 밀리초 단위의 대기 시간을 기다린다면, 이 메서드는 보다 자세한 밀리초 + 나노초 만큼만 대기한다.
void	notify()	Object 객체의 모니터에 대기하고 있는 단일 스레드를 깨운다.
void	notifyAll()	Object 객체의 모니터에 대기하고 있는 모든 스레드를 깨운다.

위의 내용들을 보면 프로세스와 스레드의 개념이 잘 잡혀 있다면, 쉽게 이해가 될 수 있을 것이다. 1차원적으로 직접적으로 설명하자면, wait() 메서드를 사용하면 스레드가 대기 상태가 되며, notify()나 notifyAll() 메서드를 사용하면 스레드의 대기 상태가 해제된다.

package com.study;
 
class StateThread1 extends Thread {
    private Object monitor;
 
    public StateThread1(Object monitor) {
        this.monitor = monitor;
    }
 
    @Override
    public void run() {
        try {
            for(int i = 0; i < 10000; i++) {
                String a = "A";
            }
            synchronized (monitor) {
                monitor.wait();
            }
            System.out.println(getName() + " is notified");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
 
    }
}
 
// entry point
public class RunThreads {
    public static void main(String[] args) {
        RunThreads sample = new RunThreads();
        sample.checkThreadState2();
    }
 
    public void checkThreadState2() {
 
        Object monitor = new Object();
        StateThread1 thread = new StateThread1(monitor);
 
        try {
            System.out.println("thread state : " + thread.getState());
            thread.start();
            System.out.println("thread state(after start) : " + thread.getState());
 
            Thread.sleep(100);
            System.out.println("thread state(after 0.1 sec) : " + thread.getState());
 
            synchronized (monitor) {
                monitor.notify();
            }
 
            Thread.sleep(100);
            System.out.println("thread state(after notify) : " + thread.getState());
 
            thread.join();
            System.out.println("thread state(after join) : " + thread.getState());
 
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
 
    }
 
}

결과는 위에서 메서드 설명을 잘 이해했다면 쉽게 이해가 될 것이다. 다만 wait()메서드가 호출되면, 스레드의 상태가 WAITING 상태가 된다. 즉 깨워주기 전까지는 계속 WAITING 상태가 유지가 된다. 이때 interrupt() 메서드를 호출하여 대기 상태에서 풀려날 수도 있겠지만, notify() 메서드를 호출해서 풀어야 InterruptedException도 발생하지 않고, wait() 이후의 문장도 정상적으로 수행하게 된다.

checkThreadState2() 메서드에 "StateThread1 thread2 = new StateThread1(monitor);" thread2 관련 내용들을 추가하였다.

    public void checkThreadState2() {
 
        Object monitor = new Object();
        StateThread1 thread = new StateThread1(monitor);
        StateThread1 thread2 = new StateThread1(monitor);
 
        try {
            System.out.println("thread state : " + thread.getState());
            thread.start();
            thread2.start();
            System.out.println("thread state(after start) : " + thread.getState());
 
            Thread.sleep(100);
            System.out.println("thread state(after 0.1 sec) : " + thread.getState());
 
            synchronized (monitor) {
                monitor.notify();
            }
 
            Thread.sleep(100);
            System.out.println("thread state(after notify) : " + thread.getState());
 
            thread.join();
            System.out.println("thread state(after join) : " + thread.getState());
            thread2.join();
            System.out.println("thread2 state(after join) : " + thread2.getState());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
 
    }

이렇게 하게되면 종료가 되지 않고 thread2가 계속 대기상태로 남아있게 된다. 이유는 monitor.notify()는 thread의 wait만 깨운다. 즉 thread2의 wait는 깨워지지 않은 것이다. 저기서 monitor.notify()를 한 줄 더 추가해서 해결할 수도 있지만, wait() 상태가 몇 개인지 모르는 상태에서는 적합한 방법이 아니다.
이럴 때에는 notifyAll() 메서드를 사용하는 것이 좋다.

 

🚀 마무리

확실히 프로세스와 스레드를 운영체제 파트를 짚고 다시 스레드 파트를 코드레벨로 공부를 하니 이해가 더 깊게 잘 되었고, 머릿속으로 메커니즘이 그려져서 뿌듯했다.

 

참고

- [교재] 자바의신(이상민 저)

- [교재] 그림으로 배우는 구조와 원리 운영체제 (구현회 저)

- https://docs.oracle.com/javase/7/docs/api/java/lang/Thread.html 

- https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html