Java 스레드

프로세스와 스레드

 

프로세스 : 실행 중인 애플리케이션. 애플리케이션을 실행하면 운영체제로부터 실행에 필요한 만큼의 메모리를 할당받아 프로세스가 된다.

 

프로세스는 데이터, 컴퓨터 자원, 스레드로 구성되는데, 스레드는 데이터와 애플리케이션이 확보한 자원을 활용하여 소스 코드를 실행한다.

즉, 스레드는 하나의 코드 실행 흐름이라고 볼 수 있다.

 

메인 스레드

 

자바 애플리케이션을 실행하면 가장 먼저 실행되는 메서드는 main 메서드이며, 메인 스레드가 main 메서드를 실행시켜준다. 메인 스레드는 main 메서드의 코드를 처음부터 끝까지 차례대로 실행시키고, 코드 끝을 만나거나 return문을 만나면 실행을 종료한다.

 

만약, 어떤 자바 애플리케이션의 소스 코드가 싱글 스레드로 작성되었다면, 그 애플리케이션이 실행되어 프로세스가 될 때 오로지 메인 스레드만 가지는 싱글 스레드 프로세스가 될 것이다. 반면, 메인 스레드에서 또 다른 스레드를 생성하여 실행시킨다면 해당 애플리케이션은 멀티 스레드로 동작하게 된다.

 

멀티 스레드

 

하나의 프로세스는 여러 개의 스레드를 가질 수 있으며, 이를 멀티 스레드 프로세스라고 한다. 

여러 개의 스레드를 가진다는 것은 여러 스레드가 동시에 작업을 수행할 수 있음을 의미하며, 이를 멀티스레딩이라고 한다.

 

멀티 스레딩은 하나의 애플리케이션 내에 여러 작업을 동시에 수행하는 멀티 태스킹을 구현하는 데에 핵심적인 역할을 수행한다.

 

예를 들어, 메신저 프로그램을 사용할 때, 상대방에게 보낼 사진을 업로드하면서 동시에 메시지를 주고받을 수 있다. 이처럼 메신저 프로그램이 여러 가지 작업을 동시에 수행하려면, 작업을 동시에 실행해 줄 스레드가 추가로 필요하다.

 

 

스레드의 생성과 실행

 

메인 스레드 외에 별도의 작업 스레드를 사용한다는 것은 다시 말해 작업 스레드가 수행할 코드를 작성하고, 작업 스레드를 생성하여 실행시키는 것을 의미한다.

 

자바는 객체지향 언어이므로 모든 자바 코드는 클래스 안에 작성되므로, 스레드가 수행할 코드도 클래스 내부에 작성해주어야 하며, run() 이라는 메서드 내에 스레드가 처리할 작업을 작성하도록 되어 있다.

 

run() 메서드는 Runnable 인터페이스와 Thread 클래스에 정의되어 있다. 따라서, 작업 스레드를 생성하고 실행하는 방법은 다음의 두 가지가 된다.

 

• 첫 번째 방법
  • Runnable 인터페이스를 구현한 객체에서 run()을 구현하여 스레드를 생성하고, 실행하는 방법
• 두 번째 방법
  • Thread 클래스를 상속받은 하위 클래스에서 run()을 구현하여 스레드를 생성하고 실행하는 방법

 

 

1. Runnable 인터페이스를 구현한 객체에서 run()을 구현하여 스레드를 생성하고 실행하는 방법

public class ThreadExample01 {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new ThreadTask1());
        thread1.start();

        for (int i = 0; i < 100; i++) {
            System.out.print("@");
        }
    }
}

class ThreadTask1 implements Runnable{
    public void run(){
        for(int i=0;i<100;i++){
            System.out.print("#");
        }
    }
}

> Task :ThreadExample01.main()
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@###@###@@@@@@@@@@@@@@@@@@@@@@@@@@@@@###@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@###########################################################################################

@와 #이 섞여 있어 메인 스레드와 작업 스레드가 동시에 병렬로 실행(동시에 독립적으로 실행된다)되면서, 각각 main 메서드와 run() 메서드의 코드를 실행시켰음을 알 수 있다.

 

 

2. Thread 클래스를 상속받은 하위 클래스에서 run()을 구현하여 스레드를 생성하고 실행하는 방법

package org.example.dev;

public class ThreadExample02 {
    public static void main(String[] args) {
        ThreadTask2 thread2 = new ThreadTask2();

        thread2.start();

        for (int i = 0; i < 100; i++) {
            System.out.print("@");
        }
    }
}

class ThreadTask2 extends Thread{
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.print("#");

        }
    }
}

> Task :ThreadExample02.main()
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@################@@@@@@@@@###########@@@@@@##@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#######################################################################

두 번째 방법 역시 위와 유사한 결과를 얻을 수 있다.

 

위 두가지 방법 모두 작업 스레드를 만들고, run() 메서드에 작성된 코드를 처리하는 동일한 내부 동작을 수행한다.

 

 

 

익명 객체를 사용하여 스레드 생성하고 실행하기

 

1. Runnable 익명 구현 객체를 활용한 스레드 생성 및 실행

package org.example.dev;

public class ThreadExample03 {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.print("#");
                }
            }
        });

        thread1.start();

        for (int i = 0; i < 100; i++) {
            System.out.print("@");
        }
    }
}

 

 

2. Thread 익명 하위 객체를 활용한 스레드 생성 및 실행

package org.example.dev;

public class ThreadExample04 {
    public static void main(String[] args) {
        Thread thread2 = new Thread() {
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.print("#");
                }
            }
        };

        thread2.start();

        for (int i = 0; i < 100; i++) {
            System.out.print("@");
        }
    }
}

 

 

스레드 동기화 문제

 

싱글 스레드 프로세스의 경우, 데이터에 단 하나의 스레드만 접근하기 때문에 문제될 것이 없으나, 멀티 스레드 프로세스의 경우, 두 스레드가 같은 데이터를 공유하게 되어 문제가 발생할 수 있다.

 

package org.example.thread;

public class ThreadExample05 {
    public static void main(String[] args) {
        Runnable threadTask3 = new ThreadTask3();
        Thread thread3_1 = new Thread(threadTask3);
        Thread thread3_2 = new Thread(threadTask3);

        thread3_1.setName("김코딩");
        thread3_2.setName("박자바");

        thread3_1.start();
        thread3_2.start();
    }
}

class Account{
    private int balance=1000;

    public int getBalance(){
        return balance;
    }

    public boolean withdraw(int money){
        if(balance>=money){
            try{
                Thread.sleep(1000);
            }catch (Exception error) {}

            balance -= money;

            return true;
        }
        return false;
    }
}

class ThreadTask3 implements Runnable{
    Account account = new Account();

    public void run(){
        while(account.getBalance()>0){
            int money = (int)(Math.random() * 3 + 1) * 100;

            boolean denied = !account.withdraw(money);

            System.out.println(String.format("Withdraw %d₩ By %s. Balance : %d %s",
                money, Thread.currentThread().getName(), account.getBalance(), denied ? "-> DENIED" : "")
            );
        }
    }
}

 

> Task :ThreadExample05.main()
Withdraw 100₩ By 박자바. Balance : 900 
Withdraw 300₩ By 김코딩. Balance : 900 
Withdraw 300₩ By 박자바. Balance : 600 
Withdraw 100₩ By 김코딩. Balance : 600 
Withdraw 300₩ By 김코딩. Balance : 300 
Withdraw 100₩ By 박자바. Balance : 200 
Withdraw 300₩ By 김코딩. Balance : -100 
Withdraw 200₩ By 박자바. Balance : -300

출력 결과를 보면, 인출금과 잔액이 제대로 출력되지 않고 있음을 알 수 있다.

 

이는 두 스레드 간에 객체가 공유되기 때문에 발생하는 오류로, 값이 왜 이렇게 출력되었는지 추측하기가 어렵다.

 

또한, withdraw()에서 잔액이 인출되고자 하는 금액보다 많은 경우에만 인출이 가능하도록 코드를 작성해 두었음에도 불구하고 (if(balance>= money) ~), 마치 조건문이 무시된 것처럼 음수의 잔액이 발생하는 것을 확인할 수 있다.

 

여기에서 음수의 잔액이 발생하는 이유는, 두 스레드가 하나의 Account객체를 공유하는 상황에서, 한 스레드가 if 문의 조건식을 true로 평가하여 if 문의 실행부로 코드의 흐름이 이동하는 시점에 다른 스레드가 끼어들어 balance를 인출했기 때문이다.

 

그리고, 알 수 없는 원인에 의해 인출에 실패한 경우에 --> DENIED가 제대로 출력되지 않는 문제도 발생한다.

 

이러한 상황이 발생하지 않게 하는 것을 스레드 동기화라고 한다.

 

스레드 동기화
👉다수의 스레드가 한 리소스에 접근하려 할 때, 사용하려는 스레드를 제외한 나머지 스레드들은 리소스를 사용하지 못하도록 막는 것.

 

 

 

임계 영역(Critical section)과 락(Lock)

 

임계 영역은 오로지 하나의 스레드만 코드를 실행할 수 있는 코드 영역을 의미하며, 락은 임계 영역을 포함하고 있는 객체에 접근할 수 있는 권한을 의미한다.

 

즉, 임계 영역으로 설정된 객체가 다른 스레드에 의해 작업이 이루어지고 있지 않을 때, 임의의 스레드 A는 해당 객체에 대한 락을 획득하여 임계 영역 내의 코드를 실행할 수 있다.

 

이때, 스레드 A가 임계 영역 내의 코드를 실행 중일 때에는 다른 스레드들은 락이 없으므로 이 객체의 임계 영역 내의 코드를 실행할 수 없다.

 

잠시 뒤, 스레드 A가 임계 영역 내의 코드를 모두 실행하면 락을 반납하고, 이때 부터 다른 스레드 중 하나가 락을 획득하여 임계 영역 내의 코드를 실행할 수 있다.

 

위 예제에서 우리에게 필요했던 것은 두 스레드가 동시에 실행하면 안되는 영역을 설정하는 것이다. 즉, withdraw() 메서드를 두 스레드가 동시에 접근하지 못하도록 해야 한다.

 

💡withdraw() 메서드를 임계 영역으로 설정한다.

 

특정 코드 구간을 임계 영역으로 설정할 때는 synchronized 라는 키워드를 사용한다.

 

 

1. 메서드 전체를 임계 영역으로 지정하기

public synchronized boolean withdraw(int money){
        if(balance>=money){
            try{
                Thread.sleep(1000);
            }catch (Exception error) {}

            balance -= money;

            return true;
        }
        return false;
    }

이렇게 메서드 전체를 임계 영역으로 지정하면 메서드가 호출되었을 때, 메서드를 실행할 스레드는 메서드가 포함된 객체의 락을 얻는다.

즉, withdraw()가 호출되면, withdraw()를 실행하는 스레드는 withdraw()가 포함된 객체의 락을 얻으며, 해당 스레드가 락을 반납하기 이전에 다른 스레드는 해당 메서드의 코드를 실행하지 못하게 된다.

 

 

2. 특정한 영역을 임계 영역으로 지정하기

public synchronized boolean withdraw(int money){
        synchronized (this){
            if(balance>=money){
                try{
                    Thread.sleep(1000);
                }catch (Exception error) {}

                balance -= money;

                return true;
            }
            return false;
        }
    }

 

특정 영역을 임계 영역으로 지정하려면 위와 같이 synchronized 키워드와 함께 소괄호 안에 해당 영역이 포함된 객체의 참조를 넣고, 중괄호({})로 블록을 열어, 블록 내에 코드를 작성하면 된다.

 

이 경우에도 마찬가지로, 임계 영역으로 설정한 블록의 코드로 코드 실행 흐름이 진입할 때, 해당 코드를 실행하고 있는 스레드가 this에 해당하는 객체의 락을 얻고, 배타적으로 임계 영역 내의 코드를 실행한다.

 

1번 처럼 메서드 전체에 락을 거는 것보다 synchronized 블록으로 임계 영역을 최소화해 효율적인 프로그램이 되도록 하는 것이 바람직하다.

 

 

Thread Safe

 

'여러 스레드가 동시에 어떤 리소스를 접근해도 프로그램이 안정적으로 동작하는 것'을 말한다.

 

즉, Thread Safe를 보장하기 위한 방법 중 하나가 스레드 동기화이며, Thread Safe는 Immutable Object를 생성해서도 보장이 가능하다.

 

 

Immutable Object를 사용하는 방법은 다음과 같다.