[Java] 쓰레드 완벽 정리

🔍 프로세스와 쓰레드

프로세스란 '실행중인 프로그램'을 말한다. 우리가 프로그램을 실행시키면 OS(윈도우, Mac 등)는 프로그램 실행에 필요한 데이터와 메모리 등의 자원을 할당한다. 프로세스는 이렇게 할당 받은 자원과 쓰레드로 구성되어 있다.

쓰레드는 '프로세스가 할당 받은 자원을 활용하여 실제 작업을 이행하는 존재' 를 말한다. 쓰레드의 생성에는 제한이 없지만, 작업을 수행하기 위한 메모리 공간을 필요로 한다. 쓰레드는 프로세스가 가지고 있는 자원을 할당받기 때문에 프로세스의 메모리 한계치까지만 생성할 수 있다.

🔍 멀티 태스킹과 멀티 쓰레딩

우리는 문서 작업을 하면서 동시에 유튜브 음악을 감상할 수 있다. 이는 윈도우와 같은 운영체제는 멀티태스킹을 제공하기 때문에 가능한 일이다. 멀티 태스킹은 두 가지 이상의 작업을 동시에 하는 것을 의미하며, 프로세스 + 프로세스 조합 뿐만 아니라 한 프로세스안의 작업1 + 작업2를 의미할 수 있다.

작업을 수행하는 CPU의 코어는 한 번에 단 하나의 작업만 수행할 수 있다. 예를 들어 문서 작업을 하면서 유튜브 음악을 동시에 하려면 최소 두 개의 코어가 필요하다. 우리는 문서 작업도하고 음악도 감상하고 메신저에서 문자를 보내면서 파일을 다운로드하기도 한다. 이렇게 한 프로세스안에서 이루어지는 작업을 처리하기 위해 코어를 사용한다면 프로그램을 몇 개 실행하지 못할 것이다.

이를 해결하기 위해 멀티 쓰레딩을 이용할 수 있다. 멀티 쓰레딩은 여러 개의 쓰레드가 번갈아가며 실행되는 것처럼 보이게 하는 기술로 코어는 매우 빠른 속도로 쓰레드를 전화하면서 각 쓰레드에게 작업을 할당한다.

🗝️ 양날의 검 - 멀티 쓰레딩

멀티 쓰레딩은 다음과 같은 장점이 있어 많이 사용된다.

CPU의 사용률이 증가한다.
자원을 보다 효율적으로 사용할 수 있다.
사용자의 요청에 빠르게 응답할 수 있다.

하지만 멀티 쓰레딩은 여러 쓰레드가 같은 프로세스 내에서 자원을 공유하면서 작업 하기 때문에 동기화, 교착상태와 같은 문제가 생길 수 있다.

🔍 쓰레드의 구현과 실행

쓰레드를 구현하는 방법에는 Thread.class를 상속하는 방법과 Runnable 인터페이스를 구현하는 방법이 있다. 두 가지 방법 모두 run() 메소드를 오버라이딩하여 몸체를 작성하면 된다.

🗝️ Thread 클래스

Thread 클래스는 Thread를 상속한 자식 인스턴스를 생성한 뒤 start() 메소드를 이용해 실행시킬 수 있다.

class ThreadEx extends Thread {
	public void run() { ... }
}

class ThreadMain {
	public static void main(String[] args) {
    	ThreadEx t = new ThreadEx();
        t.start();
    }
}

🗝️ Runnable 인터페이스

Runnable 인터페이스의 경우 Runnable을 상속한 자식 인스턴스를 상속한 뒤에 Thread(Runnable target) 생성자로 Thread를 생성하면 된다.

public class ThreadEx2 implement Runnable {
	public void run() { ... }
}

public class ThreadMain {
	public static void main(String[] args) {
    	Runnable r = new ThreadEx2();
        Thread t = new Thread(r);
        t.start();
    }
}

🗝️ Runnable이 선호되는 이유

Thread 클래스가 java.lang.Thread 클래스만 다루기 때문에 더 쉬워보이지만 Runnable이 더 많이 사용되고 있다. 이유는 다음과 같다.

자바는 다중 상속을 지원하지 않는다. 따라서 Thread를 사용한다는 것은 다른 클래스를 상속할 수 없음을 의미하기도 한다.
Runnable 인터페이스는 Thread 또는 Executors 등에 의해 실행될 수 있기 때문에 Runnable을 사용하는 것이 좋은 디자인 결정이다.
Runnable로 작업을 분리한다는 것은 그 작업을 재사용할 수 있으며 다른 실행자에 의해 실행될 수 있음을 의미한다.

🗝️ 언제 Thread을 사용해야 하는가?

OOP에서 클래스를 상속한다는 것은 새로운 기능을 추가하거나, 개선 및 수정 한다는 것을 의미한다. 따라서 Thread에서 어떠한 기능 추가나 수정을 하지 않는다면 Runnable 인터페이스를 사용하자.

🗝️ start() 메소드

쓰레드를 생성한 뒤에는 start() 메소드를 호출하여 실행시켜줘야 한다. start() 메소드가 호출되면 실행대기 상태에 있다가 자신의 상태가 되면 실행된다. 또 start()는 한 번만 호출될 수 있다.

한 가지 이상한 점은 ThreadEx 클래스는 Thread를 상속하고 run() 메소드를 오버라이딩 했다. 그런데 쓰레드를 실행시키기 위해 호출하는 메소드는 start()이다. start() 메소드에는 native 메소드로 쓰레드의 작업을 실행한다. native 메소드는 새로운 쓰레드가 작업을 실행하는데 필요한 호출스택을 생성한 다음 run() 메소드를 실행한다.

run() 메소드를 호출하면 호출 스택이 생성되지 않고 메소드만 호출되며, start() 메소드는 호출스택을 생성한 다음 run() 메소드를 실행한다.

🔍 싱글 쓰레드와 멀티 쓰레드

하나의 쓰레드로 두 개의 작업을 하는 경우 P1을 마친 후에 P2의 작업을 시작한다. 두 개의 쓰레드로 두 개의 작업을 하는 경우 짧은 시간동안 두 개의 쓰레드가 번갈아 가면서 수행된다.

단순 연산의 경우 단일 쓰레드의 작업이 오래걸리기도 한다. 이는 쓰레드간의 컨텍스트 스위칭이 발생하기 때문이다. 컨텍스트 스위칭이란 다음에 실행해야할 위치 등의 정보를 저장하고 읽어 오는 과정을 의미한다. 멀티 코어에서 멀티 쓰레드를 사용하는 경우에는 자원을 기다리는 시간이 생길 수 있다. 예를 들어 한 쓰레드가 화면에 출력하고 있는 동안 다른 쓰레드는 출력이 끝나기를 기다려야 한다.

두 쓰레드가 서로 다른 자원을 사용하는 경우에는 멀티 쓰레드가 더 효율적이다. 예를 들면 사용자로부터 데이터를 입력받는 작업, 네트워크로 파일을 주고 받는 작업 등이 해당된다.

🔍 쓰레드의 우선순위

setPriority(int priority), getPriority()를 이용하여 쓰레드의 우선순위를 지정하거나 확인할 수 있다. 우선순위 범위는 1 ~ 10이며 숫자가 높을수록 우선순위가 높다.

멀티코어에서는 쓰레드의 우선순위에 따른 차이가 거의 없으며, OS마다 다른 방식으로 스케쥴링 하기 때문에 결과가 달라질 수 있다. 따라서 쓰레드에 우선순위를 부여하기보다 우선순위를 PriorityQueue에 저장해 놓고, 우선순위가 높은 작업이 먼저 처리되도록 하는 것이 좋다.

🔍 데몬 쓰레드

데몬 쓰레드는 일반 쓰레드의 작업을 돋는 보조 쓰레드이다. 예를 들어 문서 프로그램의 자동저장, 화면자동갱신 등이 있다. 기본적으로 구현은 무한루프와 조건문을 이용해서 실행 후 대기하고 있다가 특정 조건이 만족되면 작업을 수행하고 다시 대기하도록 작성한다. 데몬 쓰레드는 실행하기 전에 setDaemon(true)를 호출해야 한다.

public class DaemonThreadExample {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.setDaemon(true);
        myThread.start();

        // 메인 스레드 실행 중
        try {
            Thread.sleep(3000); // 3초간 대기
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("메인 스레드 종료");
    }
}

class MyThread extends Thread {
    public void run() {
        while (true) {
            System.out.println("데몬 스레드 실행 중");
            try {
                Thread.sleep(1000); // 1초간 대기
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

🔍 쓰레드의 실행제어

쓰레드의 실행을 제어하는 sleep(), join(), interrupt(), suspend(), resume(), yield()에 대해 알아보자.

🗝️ 쓰레드의 상태 그래프

쓰레드를 생성하고 실행하지 않은 상태를 NEW라고 하며, start() 메소드를 호출하면 실행 대기(Runnable) 상태가 된다.
실행 대기 상태에서 차례대로 실행이 된다.
주어진 실행시간이 다 되거나 yield()가 호출되면 다시 실행 대기상태가 된다.
실행 중에 suspend(), sleep(), wait(), join(), I/O block에 의해 일시정지상태가 될 수 있다.
일시정지시간이 다되거나 notify(), resume(), interrupt() 메서드가 호출되면 다시 실행대기 상태가 된다.
실행을 모두 마치면 소멸(TERMINATED) 된다.

🗝️ sleep() 메소드

sleep()은 지정된 시간동안 쓰레드를 멈추게 한다. sleep()에 의해 일시정지 상태가 된 쓰레드는 지정된 시간이 다 되거나 interrupt()가 호출되면 InterruptedException이 발생하고, 실행대기 상태가 된다. 따라서 sleep()을 호출할 때는 항상 try-catch문으로 예외를 처리해줘야 한다.

void delay(long millis) {
    try {
    	Thread.sleep(millis);
    } catch (InterruptedException e ) {}
}

sleep()은 항상 현재 실행 중인 쓰레드에 대해 작동하기 때문에 참조변수가 아닌 "Thread.sleep()" 다음과 같이 스태틱 메소드를 이용해야 한다.

🗝️ interrupt()와 interrupted()

진행 중인 쓰레드를 작업이 끝나기 전에 취소하는 경우(e.g 예를 들어 파일을 다운로드 하다가 중간에 취소하는 경우)에는 interrupt를 이용하여 작업을 취소할 수 있다.

// 쓰레드의 interrupted 상태를 false에서 true로 변경한다.
void interrupt() 

// 쓰레드의 interrupted상태를 반환한다.
boolean isInterrupted

// 현재 쓰레드의 interrupted상태를 반환 후, false로 변경한다.
static boolean interrupted()

public class InterruptExample {
    public static void main(String[] args) {
        Thread myThread = new MyThread();
        myThread.start();

        try {
            Thread.sleep(2000); // 2초간 대기
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 스레드 인터럽트
        myThread.interrupt();
    }
}

class MyThread extends Thread {
    public void run() {
        while (!isInterrupted()) {
            try {
                System.out.println("스레드 실행 중");
                Thread.sleep(500); // 0.5초간 대기
            } catch (InterruptedException e) {
                System.out.println("인터럽트 발생");
                // 스레드 인터럽트 상태를 체크하고 필요한 작업 수행
                // 예: 자원 정리, 종료 등
                return; // 스레드 종료
            }
        }
    }
}

🗝️ suspend(), resume()

위의 세 메소드는 스레드를 일시 정지시키고 재개시키는 기능을 제공하지만 사용 시 교착 상태와 스레드 일관성 문제가 발생할 수 있다. 따라서 권장되지 않으며, wait(), notify(), Lock과 같은 스레드 동기화 메커니즘을 사용하는 것이 좋다.

🗝️ yield()

현재 실행 중인 스레드를 일시적으로 정지 시키고 다른 스레드가 실행 되도록 양보(yield)한다.

class MyThread extends Thread {
    private String name;

    public MyThread(String name) {
        this.name = name;
    }

    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println(name + ": " + i);
            // 스레드 실행 중간에 다른 스레드에게 실행 기회를 양보
            Thread.yield();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread1 = new MyThread("Thread 1");
        MyThread thread2 = new MyThread("Thread 2");

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

위의 코드에서는 두 개의 쓰레드가 번갈아가며 실행되는 것을 확인할 수 있다.

🗝️ join()

호출한 스레드는 join() 메서드를 호출한 스레드가 종료될 때까지 대기한다.

public class JoinExample {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new MyThread("Thread 1"));
        Thread thread2 = new Thread(new MyThread("Thread 2"));
        Thread thread3 = new Thread(new MyThread("Thread 3"));

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

        try {
            thread1.join(); // thread1이 종료될 때까지 대기
            thread2.join(); // thread2가 종료될 때까지 대기
            thread3.join(); // thread3이 종료될 때까지 대기
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("메인 스레드 종료");
    }
}

class MyThread implements Runnable {
    private String name;

    public MyThread(String name) {
        this.name = name;
    }

    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println(name + ": " + i);
            try {
                Thread.sleep(1000); // 1초간 대기
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

main 메서드는 thread1,2,3가 모두 순차적으로 실행되고 종료될 때까지 대기하게 된다.

저작자표시 비영리 변경금지 (새창열림)