[Java] Thread 기초

1. 스레드의 개념

운영체제 - 프로세스의 개념 도식

정적인 프로그램이 자원(CPU나 메모리)을 얻어 실행 중에 들어간 것을 프로세스라 하며, 모든 프로그램은 기본적으로 프로세스 단위로 실행된다. 스레드는 프로세스 내의 작은 실행 단위이며 프로세스는 하나의 스레드로 구성되거나 여러 개의 작은 스레드로 구성될 수 있다.

JAVA 프로그램을 실행시키면 JVM 상에 자동으로 스레드가 하나 생성되고 이를 ‘메인 스레드’ 라 한다. 메인 스레드 내에서 여러 스레드를 생성하거나 실행할 수 있고, 모든 스레드는 우선순위(priority)를 가지는데, 처음에는 기본적으로 자신을 생성한 스레드와 동일한 우선순위를 가지고 생성된다. 각 스레드 별 우선순위를 임으로 설정할 수도 있다. 이때 스레드를 추상화 한 Thread 클래스를 이용한다.

2. 스레드 클래스

다음은 자바 스레드 클래스 내부의 주요 상수와 생성자, 그리고 메서드를 살펴보자.

2-1. 주요 상수

/* 스레드의 데몬 여부 */
private boolean daemon = false;

/* 스레드의 상태 */
private volatile int threadStatus;

/* 스레드 우선순위 최소값 */
public static final int MIN_PRIORITY = 1;

/* 스레드 우선순위 기본값 */
public static final int NORM_PRIORITY = 5;

/* 스레드 우선순위 최대값 */
public static final int MAX_PRIORITY = 10;

2-2. 주요 생성자

/**
* 1. 스레드 그룹
* 2. Runnable Interface 를 상속받는 실행 대상
* 3. 스레드 네임 (기본 값으로 "Thread-" + nextThreadNum() 형식을 가진다
*/
public Thread(ThreadGroup group, Runnable target, String name) {
    this(group, target, name, 0);
}

2-3. 주요 메서드

//현재 실행중인 스레드가 this 스레드를 제어할 권한이 있는지 확인한다.
//없다면 SecurityException 을 반환한다.
public final void checkAccess() {...}

//this 스레드의 우선순위를 설정한다.
public final void setPriority(int newPriority) {...}

//실행 중단상태에 있는 this 스레드를 깨운다.
public void interrupt() {...}

//this 스레드가 종료될 때 까지 기다리거나 지정된 시간(milllis) 만큼 기다린다.
public final synchronized void join() throws InterreptedException {...}
public final synchronized void join(long millis) throws InterreptedException {...}

//현재 실행중인 스레드를 일시적으로 멈추게 해서 다른 스레드가 실행되도록 한다.
public static void yeild() {...} 

//현재 스레드를 지정된 시간(millis) 만큼 실행을 멈춘다. 
public static void sleep(long millis) {...}

2-4. Object 클래스의 스레드 관련 주요 메서드

//현재 스레드를 다른 스레드가 notify() 혹은 notifyAll() 을 호출할때까지 대기시킨다.
public final native void wait() throws InterruptedException;
public final native void wait(long timeoutMillis) throws InterruptedException;

//대기중인 스레드를 하나 혹은 모두 깨운다.
public final native void notify();
public final native void notifyAll();

3. 스레드의 생성

스레드의 생성에는 두 가지 방법이 있다. Thread 클래스를 상속받거나 Runnable 인터페이스의 구현체로 생성하는 방법이 있다. JAVA는 다중상속이 불가능하므로 다른 클래스를 상속받으면서 스레드로 실행하기 위해서는 Runnable 인터페이스의 구현체로 사용해야 한다.

3-1. Thread 클래스를 상속받기

class Scratch {

    public static void main(String[] args)  {

        MyThread thread = new MyThread();
        // 3.start() 메서드를 통해 실행한다.
        thread.start();
    }	
}

//1. Thread 클래스를 상속받는 클래스를 정의한다.
class MyThread extends Thread {

    // 2. run() 메서드를 재정의한다.
    @Override
    public void run() {

        for (int i = 0; i < 10; i++) {
            System.out.println("[" + this.getName() + "]i = " + i);
        }
    }
}

3-2. Runnable 인터페이스를 구현하기

class Scratch {

    public static void main(String[] args)  {

        // 3.Runnable 인터페이스를 상속받은 인스턴스를 파라미터로 Thread 클래스를 생성한다
        Thread thread = new Thread(new MyThread());
        // 4.start() 메서드를 통해 실행한다.
        thread.start();
    }
}

//1. Runnable 인터페이스의 구현체로 생성한다.
class MyThread implements Runnable {

    // 2. run() 메서드를 재정의한다.
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("i = " + i);
        }
    }
}

1번과 2번에 대한 실행 결과

3-EX. Thread 메서드의 start() 메서드를 통해서만 실행시켜야 하는 이유

Runnable 인터페이스의 run() 메서드를 직접 실행시키지 않는 이유는 Thread 객체의 start() 메서드를 통해서만 JVM이 새로운 스레드를 생성하고 run() 메서드 영역의 코드를 실행시키기 때문이다.

그냥 run() 메서드를 실행시킨다면 새로운 스레드를 생성하지 않고 싱글 스레드 영역에서 run() 메서드의 내용만을 실행시킨다.

class Scratch {

    public static void main(String[] args)  {

        MyThread thread1 = new MyThread();
        thread1.run();

        MyThread thread2 = new MyThread();
        thread2.run();

        System.out.println("===== main end =====");
    }
}

class MyThread implements Runnable {

    @Override
    public void run() {
        for (int i = 1; i <= 3; i++) {
            System.out.println("[" + Thread.currentThread().getName() + "] i = " + i);
        }
    }
}

병렬처리가 되지 않고 메인스레드에서 순차적으로 실행되고 있다.

4. 스레드의 상태

다음은 스레드가 생성되고 CPU의 자원을 얻어 실행 된 후, 종료 상태에 이르기까지 가질 수 있는 상태들이다.

4-1. Startable 상태

Thread 클래스를 생성하여 객체를 생성한 상태이다. 즉, start() 메서드 호출 바로 직전의 상태이다. 모든 스레드는 Startable 상태에서만 Runnable 상태로 넘어갈 수 있다.

스레드의 상태 도식

4-2. Runnable 상태

Running 상태의 바로 직전 상태이고, 실행을 위한 모든 준비가 끝났으며 CPU 자원만 얻으면 바로 실행할 수 있는 상태를 의미한다.

4-3. Running 상태

스레드에 정의된 run() 메소드가 실제로 실행되고 있는 상태이다.

4-4. Not Running 상태

Running 상태에서 CPU 자원을 잃어 실행이 중단된 상태이다. 실행을 중단시키는 방법은 스스로 Thread 클래스의 sleep() 메서드나 Object 클래스의 wait() 메서드를 호출하는 것이다.

4-5. Dead 상태

스레드가 종료된 상태를 의미한다. 종료된 스레드가 다시 시작하려면 반드시 Startable 상태를 거쳐야 한다.

5. 스레드의 제어

스레드의 제어는 스레드의 상태를 변경시키는 것을 의미한다. 스레드를 제어할 때 주의점은 가급적 스레드를 직접 종료시키는 것을 피하는 것이 좋다.

5-1. 우선순위를 통한 제어

절대적인 동작 순서를 보장하지는 않지만 우선순위가 높은 스레드는 낮은 스레드에 비해 상대적으로 CPU 자원을 얻을 수 있는 확률이 높으므로 우선순위를 통해 제어할 수 있다.

class Scratch {
    public static void main(String[] args) {

        Thread threadMIN = new Thread(new MyThread("MIN"));
        Thread threadNORM = new Thread(new MyThread("NORM"));
        Thread threadMAX = new Thread(new MyThread("MAX"));

        //우선순위 낮음
        threadMIN.setPriority(Thread.MIN_PRIORITY);
        //우선순위 중간
        threadNORM.setPriority(Thread.NORM_PRIORITY);
        //우선순위 높음
        threadMAX.setPriority(Thread.MAX_PRIORITY);

        threadMIN.start();
        threadNORM.start();
        threadMAX.start();
    }
}

class MyThread implements Runnable {

    private String threadName;

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

    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
        }
        System.out.println("[" + threadName + "] END");
    }
}

반드시 위 순서대로 작동을 보장하지는 않는다.

5-2. Thread 클래스의 메소드를 통한 제어

Thread 클래스의 yield(), join(), interrupt() , sleep() 메서드를 이용하여 스레드를 제어할 수 있다.

yield() 메서드를 사용하는 경우 아주 짧은 시간동안 스레드가 Runnable 상태로 들어가서 다른 스레드에 CPU를 양보한다.

class Scratch {

    public static void main(String[] args)  {

        Thread thread1 = new Thread(new MyThread(), "thd1");
        Thread thread2 = new Thread(new MyThread(), "thd2");

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

class MyThread implements Runnable {

    @Override
    public void run() {

        String threadName = Thread.currentThread().getName();

        for (int i = 1; i <= 100; i++) {
            System.out.print("[" + threadName + "] ");
            if (threadName.equals("thd1")) Thread.yield();
        }
    }
}

비교적(?) 균등하게 교차되고 있다.

join() 메서드를 이용하는 경우 특정 스레드가 끝날 때까지 스레드를 끝내지 않고 멈추게 할 수 있다. join() 메서드를 사용할 때에는 InterruptedException 예외처리를 해 주어야 한다.

class Scratch {

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

        Thread thread1 = new Thread(new MyThread(), "thd1");
        Thread thread2 = new Thread(new MyThread(), "thd2");

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

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

        System.out.println("==== main end ====");
    }
}

class MyThread implements Runnable {

    @Override
    public void run() {
        String threadName = Thread.currentThread().getName();
        for (int i = 1; i <= 5; i++) {
            System.out.println("[" + threadName + "] ");
        }
    }
}

join() 메서드의 사용 결과

이번에는 특정 스레드를 기다리게 하는 것이 아니라, 대기상태에 있는 스레드를 깨우는(Not Running → Running) interrupt() 메서드를 사용하는 경우를 살펴보자.

class Scratch {

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

        MyThread thread1 = new MyThread("thread1");
        MyThread thread2 = new MyThread("thread2");
        MyThread thread3 = new MyThread("thread3");

        thread1.setNextThread(thread2);
        thread2.setNextThread(thread3);
        thread3.setNextThread(thread1);

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

        try {
            //InterruptedException 을 발생시킨다.
            thread1.interrupt();
            thread1.join();
            thread2.join();
            thread3.join();
        } catch (InterruptedException e) {
            System.out.println(e);
        }

        System.out.println("===== main end =====");
    }
}

class MyThread extends Thread {

    private Thread nextThread;

    public MyThread(String threadName) {
        super(threadName);
    }

    @Override
    public void run() {
        String threadName = Thread.currentThread().getName();
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(1000000);
            } catch(InterruptedException e) {
                System.out.print("[" + threadName + "] -> ");
                //다음 스레드를 깨운다.
                if(nextThread.isAlive()) nextThread.interrupt();
            }
        }
    }

    public void setNextThread(Thread nextThread) {
        this.nextThread = nextThread;
    }
}

위의 코드는 sleep 상태에 있는 스레드를 순차적으로 interrupt 하면서 스레드의 흐름을 제어하는 코드이다.

다음과 같이 인위적으로 스레드 실행 순서를 제어하는 것도 가능하다.

6. 스레드 동기화

하나의 자원을 공유하는 여러 스레드 간에 동기화를 하지 않으면 간섭 현상이 발생한다. 간섭 현상이란 공유 자원의 일관성이 깨지는 것을 의미한다.

간단한 예로 공유 자원의 일관성이 깨지는 상황을 살펴보자.

class Counter {
    
    private int c = 0;

    public void increment() {
        System.out.println("[" + Thread.currentThread().getName() + "] " + (++c));
    }
    public int getValue() {
        return c;
    }
}

class CounterRunner implements Runnable {

    private final Counter c;

    public CounterRunner(Counter c) {
        this.c = c;
    }

    public void run() {
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(500);
                c.increment();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

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

        Counter c = new Counter();
        Thread threadA = new Thread(new CounterRunner(c), "A");
        Thread threadB = new Thread(new CounterRunner(c), "B");

        threadA.start();
        threadB.start();

        threadA.join();
        threadB.join();

        System.out.println("c = " + c.getValue());
    }
}

스레드 두개가 하나의 공유 자원(Counter 객체)에 접근해 변수의 값을 조작하고 있다. 정상적으로 기대할 수 있는 값은 두 스레드가 각각 다섯 번씩 객체의 값을 증가시켰으므로 10이지만 실제 결과를 보자.

잘못된 결과 1

잘못된 결과 2

결과는 매번 다르지만(정상적인 결과가 나올때도 있다), 올바른 결과를 보장하지 못한다는 것을 알 수 있다.

이렇게 병렬 스레드간의 간섭 현상으로 인해 일관성을 해치는 문제를 동시성 이슈(Concurrency Issue)라고 한다. 그리고 이러한 동시성 이슈를 해결하기 위해 synchronized 키워드를 사용할 수 있다.

synchronized 키워드는 다음과 같은 범위에서 사용할 수 있다.

• 인스턴스 메서드
• 정적 메서드
• 코드 블록

JAVA는 동기화를 위해 모니터라는 동기화 기법을 사용한다. 모니터 기법은 쉽게 말하면 synchronized로 선언된 영역 내에는 한 번에 하나의 스레드만 진입하도록 허용하는 기법이다. 모니터에 특정 스레드가 진입하면 모니터 락을 획득하고 그 외의 스레드는 큐에서 대기한다.

위의 코드에 synchronized 키워드를 적용해보자.

// ...
// Counter.class
public synchronized void increment() {
    System.out.println("[" + Thread.currentThread().getName() + "] " + (++c));
}
// ...

// ...
// Counter.class
public void increment() {
    synchronized (this) {
        System.out.println("[" + Thread.currentThread().getName() + "] " + (++c));
    }
}
// ...

다음과 같이 인스턴스 메서드 전체를 동기화 영역으로 만들거나, 특정 코드만 동기화 작업으로 수행하는 동기화 블럭을 만들어 줄 수 있다. 동기화 영역을 지정한 후 앞선 코드를 다시 한번 실행하면 다음과 같은 실행 결과를 얻을 수 있다.

Refferences

1. 🔗Guide to the Synchronized Keyword in Java - Baeldung
2. 🔗What is a Monitor in Computer Science? - Baeldung
3. 🔗Guide to the Synchronized Keyword in Java - Baeldung
4. 🔗모니터(동기화) - 위키백과
5. KNOU - JAVA 프로그래밍 11강 멀티 스레드 프로그래밍