자바 : 스레드(1)

🚀  프로세스?

우선 스레드를 알기 전 반드시 "프로세스"라는 것을 알아야만 한다. 그래야 왜 스레드를 쓰는지를 알 수 있기 때문이다. 프로세스를 보통 다양하게 정의한다. 그중 "실행 중인 프로그램"이라는 표현을 많이 사용한다. 여기서 우리는 "프로그램"이라는 단어의 정의를 알아보자.

프로그램이란? 
컴파일한 코드와 초기화 전역 변수, 문자열과 문자열 상수 등 정적 데이터를 포함하는 정적인 개체이다. 

그렇다면 "실행 중인 프로그램"을 풀어서 해석해보면, 디스크에 있던 프로그램을 메모리에 적재하여 운영체제의 제어를 받는 상태가 되었다는 것. 즉, 자신만의 메모리 영역이 있음을 뜻한다. 결국 프로세스의 정의다.

프로세스 정의를 좀 더 세련되게 정리하자면, 메모리 구조를 이루고, 프로그램 카운터나 레지스터처럼 현재 어떤 자원을 사용하는지 관련 정보가 들어 있는 동적인 개체로 표현할 수 있다. 또 프로세스는 하나 이상의 스레드를 반드시 갖는다.

운영체제는 프로세스의 실행을 제어한다. 그리고 프로세스는 실행하면서 상태가 변하므로(생성, 준비, 실행, 대기, 종료,...) 운영체제는 프로세스 제어에 필요한 상태를 점검하고 프로세스를 제어한다.

대략적으로 요약하자면 이렇다. 물론 프로세스 제어블록 등 알아야 할 것들이 많이 있으나 이번 블로깅 주제를 넘어가므로 여기까지만 언급하겠다.

🚀  스레드?

위에서 프로세스를 주저리주저리 설명한 이유는 스레드란 녀석은 결국 프로세스의 안에서 활동하는 녀석이기에 프로세스를 전혀 알지 못하고서는 이야기가 시작될 수 없기 때문이다. 
위의 프로세스 내용들을 큰 틀에서 키워드를 뽑아보자면 자원과 제어로 구분할 수 있다. 이중 제어만 분리한 실행 단위를 스레드라고 하는데, 프로세스 하나는 스레드 한 개 이상으로 나눌 수 있다.

좀 더 특징들을 나열해보겠다..
- 스레드들은 프로세스의 직접 실행 정보를 제외한 나머지 프로세스 관리 정보를 공유한다.(직접 실행 정보 : 스택, 레지스터 // 나머지 프로세스 관리 정보 : 메모리(코드, 전역 데이터, 힙)) -> 그림 1을 보면 프로세스 안의 모습이다.

- 스레드는 프로그램 카운터와 스택 포인터 등을 비롯한 스레드 실행 환경 정보(문맥 정보), 지역 데이터, 스택 등을 독립적으로 가지면서 코드, 전역 데이터, 힙을 다른 스레드와 공유한다.

- 같은 프로세스의 스레드들은 동일한 주소 공간을 공유한다.

프로세스가 하나인 서로 다른 프로세서에서 프로그램의 다른 부분을 동시에 실행할 수 있는데, 스레드를 이용하면 다음 이점이 있다.
1.  사용자 응답성 증가 : 응용프로그램의 일부분을 봉쇄하거나 긴 작업을 수행하더라도 병렬 프로그래밍을 계속 실행할 수 있어 사용자 응답성이 증가한다.
2. 프로세스의 자원과 메모리 공유 가능
3. 경제성이 좋다.
4. 다중 처리(멀티 프로세싱)로 성능과 효율성이 향상된다.

좀 더 풀어서 설명을 하면 프로세스 하나 시작하려면 많은 자원이 필요하다. 만약 하나의 작업을 동시에 수행하려고 할 때 여러 개의 프로세스를 띄워서 실행하면 각각 메모리를 할당해야만 한다. JVM은 기본적으로 아무런 옵션 없이 실행하면, 적어도 32MB ~ 64MB의 물리 메모리를 점유한다. 그에 반에서 스레드 하나를 추가하면 1MB 이내의 메모리를 점유한다. 더 빠른 시간에 결과를 제공해주고 보다 빠른 처리가 가능해진다.

자바에서 클래스 파일을 에디터를 통해서든 직접 하든 실행하게 되면, 적어도 하나의 JVM이 시작된다. 이렇게 JVM이 시작되면, 자바 프로세스가 시작한다. 이 프로세스라는 울타리 안에서 하나 혹은 여러 개의 스레드들이 동작하게 된다.

이 정도면 스레드의 당위성은 충분히 설명이 되었을 거라 생각하며 예제를 통해 사용법을 알아보자

그림1

🎯 Runnable 인터페이스와 Thread 클래스

스레드를 생성하는 것은 크게 Runnable 인터페이스를 사용하는 것과, Thread 클래스를 사용하는 방법이 있다. 모두 java.lang 패키지에 있다. 또 Thread 클래서는 Runnable 인터페이스를 구현하였다. 사실상 같은 녀석이라는 것이다.

그렇다면 왜? 굳이 두 가지의 방식이 존재하는 것일까? 

그 이유는 상속이라는 관점에서 생각해보면 원인을 쉽게 찾을 수 있다. 자바에서는 하나의 클래스만 확장할 수 있는 특성. 즉, 다중 상속이 불가하다. 이러한 이유로 내가 다른 클래스를 확장해야 하는데 그 다른 클래스가 Thread를 확장하고 있지 않다면 더 이상 확장할 길이 없는 것이다. 한마디로 어떤 상황에서는 다중 상속이 필요해진다는 것이다.
이 시점에 인터페이스 특징을 살펴보면 요 녀석은 여러 개의 인터페이스를 구현해도 가능하다는 것이다.

이 부분을 간단히 설명하면 확장이 필요한 경우에는 Runnable 인터페이스를 사용하면 되는 것이고, 그렇지 않은 경우에는 Thread 클래스를 사용하면 된다. 

예제를 통해 살펴보자

 

package com.study;
 
// Runnable interface 구현
class RunnableSample1 implements Runnable {
    @Override
    public void run() {
        System.out.println("my runnable thread !");
    }
}
 
// Thread 클래스 상속
class ThreadsSample1 extends Thread {
    @Override
    public void run() {
        System.out.println("my thread !");
    }
}
 
// entry point
public class RunThreads {
    public static void main(String[] args) {
        RunThreads sample = new RunThreads();
        sample.runBasic();
    }
 
    public void runBasic() {
        RunnableSample1 runable = new RunnableSample1();
        new Thread(runable).start();
 
        ThreadsSample1 thread = new ThreadsSample1();
        thread.start();
 
        System.out.println("End!");
    }
}
 

 

스레드가 수행되는 구현하는 메서드는 run() 메서드이다.
스레드를 시작하는 메서드는 start()이다.
Runnable 인터페이스를 구현한 RunnableSample1 클래스를 스레드로 바로 시작할 수 없다. 반드시 Thread 클래스의 생성자에 해당 객체를 추가하여 시작해 주어야만 한다.

 

 

코드의 결과이다. 이 결과를 보면 순서가 계속 바뀌는 것을 확인할 수 있는데, 이는 위의 스레드 설명을 보면 쉽게 이해할 수 있다. 바로 따로(병렬) 일을 동시에 시작하기 때문이다. start()를 통해 시작하면 하나의 스레드가 JVM에 추가하여 실행된다. 이렇게 실행된 스레드들은 스레드들 마다 끝나는 순서가 그때그때 다른 것이다. 그리고 기다리지 않고 본인의 임무를 완료한 즉시 종료하게 된다. 그리고 여기서 하나 짚고 넘어가야 할 점은 스레드가 생성될 때마다 별도의 스택이 할당된다는 것이다.

 

🎯 데몬 스레드

 

package com.study;
 
class EndlessThread1 extends Thread {
    @Override
    public void run() {
        while(true) {
            try {
                System.out.println(System.currentTimeMillis());
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
 
// entry point
public class RunThreads {
    public static void main(String[] args) {
        RunThreads sample = new RunThreads();
        sample.endless();
    }
 
    public void endless() {
        EndlessThread1 thread = new EndlessThread1();
        thread.start();
    }
 
}

 

위의 코드를 실행시켜보면 main() 메서드의 수행이 끝나도, main() 메서드나, 다른 메서드에서 시작한 스레드가 종료하지 않으면 해당 자바 프로세스는 끝나지 않는다. 
이제 아래의 코드를 보자.

 

package com.study;
 
class DaemonThread1 extends Thread {
    @Override
    public void run() {
        while (true) {
            try {
                System.out.println(System.currentTimeMillis());
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
 
// entry point
public class RunThreads {
    public static void main(String[] args) {
        RunThreads sample = new RunThreads();
        sample.runDaemonThread();
    } 
 
    public void runDaemonThread() {
        DaemonThread1 thread = new DaemonThread1();
        thread.setDaemon(true);
        thread.start();
    }
 
}

 

위의 코드를 실행시켜보면 앞의 코드에서 setDaemon만 추가되었지만, 무한루프에 빠지지 않고 종료가 되어버린다. 즉 어떤 스레드를 데몬으로 지정하면, 그 스레드가 수행되고 있든, 수행되지 않고 있든 상관없이 JVM이 끝날 수 있다. 단 해당 스레드가 시작되기 전 데몬 스레드가 지정되어야만 한다.(setDaemon(true))
그러면 왜? 이러한 데몬 스레드를 만들었을까?

자바에서 스레드는 각자의 작업이 끝날 때까지 계속해서 작업을 하게 되어 있다. 그런데 필요에 따라서 계속할 필요가 없는 스레드도 있다. 예를 들어 문서 편집기에 자동 저장 기능이 있고, 그 자동 저장 기능이 별도의 스레드로 돌고 있다고 가정을 해보자.
이때 문서 편집기가 끝나면 자동 저장 기능 스레드는 사라지는 게 당연한 것이다. 그래서 나온 것이 데몬 스레드이다.

데몬(daemon) 스레드
: 주 스레드의 작업을 돕는 보조적인 역할을 수행하는 스레드
: 주 스레드가 종료되면 데몬 스레드는 강제적으로 자동 종료
 => 워드 프로세서의 자동 저장, 미디어 플레이어의 동영상 및 음악 재생, 가비지 컬렉터

 

🎯 Synchronized

어떤 클래스나 메서드가 스레드에 안전하려면, synchronized를 사용해야만 한다.
여러 스레드가 한 객체에 선언된 메서드에 접근하여 데이터를 처리하려고 할 때 동시에 연산을 수행하여 값이 꼬이는 경우가 발생할 수 있다. 즉, 매개변수나 메서드에서만 사용하는 지역 변수만 다루는 메서드는 전혀 필요가 없다.

synchronized는 두 가지 방법으로 사용할 수 있다.
- 메서드 자체를 synchronized로 선언하는 방법 : synchronized methods
- 메서드 내의 특정 문장만 synchronized로 감싸는 방법 : synchronized statements

만약 이 synchronized라는 단어가 메서드 선언부에 있으면, 동일한 객체의 이 메서드에 여러 개의 스레드가 접근하여도 한 순간에는 하나의 스레드만 이 메서드를 수행하게 된다.

🎯 Synchronized : synchronized methods

package com.study;
 
class CommonCalc {
    private int amount;
 
    public CommonCalc() {
        amount = 0;
    }
    public void plus(int value) {
        amount += value;
    }
    public void minus(int value) {
        amount -= value;
    }
    public int getAmount() {
        return amount;
    }
}
 
class ModifyAmountThread1 extends Thread {
    private CommonCalc calc;
    private boolean addflag;
 
    public ModifyAmountThread1(CommonCalc calc, boolean addFlag) {
        this.calc = calc;
        this.addflag = addFlag;
    }
 
    @Override
    public void run() {
        for(int i = 0; i < 10000; i++) {
            if(addflag) {
                calc.plus(1);
            } else {
                calc.minus(1);
            }
        }
    }
}
 
// entry point
public class RunThreads {
    public static void main(String[] args) {
        RunThreads sample = new RunThreads();
        sample.runCommonCalc();
    }
 
    public void runCommonCalc() {
        CommonCalc calc = new CommonCalc();
        ModifyAmountThread1 thread1 = new ModifyAmountThread1(calc, true);
        ModifyAmountThread1 thread2 = new ModifyAmountThread1(calc, true);
 
        thread1.start();
        thread2.start();
 
        try {
            thread1.join();
            thread2.join();
 
            System.out.println("Final value is " + calc.getAmount());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
 
    }
 
}

위의 코드에서 runCommonCalc()를 통해 thread1, thread2 가 실행된다. 여기서 각각 10000 씩 plus 하여 20000이라는 값을 기대하겠지만 막상 실행을 시켜보면, "Final value is 15749" 이런 식으로 이상한 값이 찍힐 것이다. 또 여러 번 수행시킬 때마다 값이 바뀔 것이다. 이는 두 개의 스레드가 동일 객체의 plus메서드를 통해 데이터에 동시에 접근하여 값을 경신하였기에 꼬인 것이다. 즉 thread1은 데이터가 1일 때 변수의 값을 1을 더해서 갱신시켰는데, thread2도 데이터가 1일 때 변수의 값을 동시에 1을 증가시켜 버린 꼴이 된 것이다. 원래의 값 1과, thread1의 1, thread2의 1이 더해져서 3이 되어야 했지만 2가 찍혀버린 것이다. 

이 상황이 은행에서 벌어졌다고 생각해보자 끔찍한 재앙이 될 것이다...

plus 메서드에 synchronized를 붙여주고 실행을 해보면, 우리가 생각한 "Final value is 20000" 그 값이 찍힌다. 이제 plus메서드는 스레드에 안전하다고 할 수 있다.

 

    public synchronized void plus(int value) {
        amount += value;
    }

 

🎯 Synchronized : synchronized statesments

위에서처럼 메서드 전체를 synchronized 해버릴 경우 성능상 문제점이 발생할 수 있다. 
예를 들어 어떤 클래스에 30줄짜리 메서드가 있다고 가정해보자. 그 클래스에도 amount라는 인스턴스 변수가 있고, 30줄짜리 메서드에서 amount라는 변수를 한 줄에서만 다룬다. 만약 해당 메서드 전체를 synchronized로 선언한다면, 나머지 29줄의 처리를 할 때 필요 없는 대기 시간이 발생하게 된다. 이러한 경우에는 메서드 전체를 감싸면 안 되며, amount라는 변수를 처리하는 부분만 synchronized 처리를 해 주면 된다.

 

    // synchronized (this) 이후에 있는 중괄호 내에 있는 연산만 동시에 여러 스레드에서 처리하지 않겠다는 뜻이다.
    public void plus(int value) {
        synchronized (this) {
            amount += value;            
        }
    }
    
    // 일반적으로는 이렇게 사용한다.
    Object lock = new Object();
    public synchronized void minus(int value) {
        synchronized (lock) {
            amount -= value;            
        }
    }

여기서 사용한 lock이라는 객체나, 앞서 사용한 this는 모두 문지기라고 볼 수 있다. 문지기는 하나의 스레드만 일을 할 수 있도록 허용해준다. 만약 블록에 들어간 스레드가 일을 다 처리하고 나오면, 문지기는 대기하고 있는 다른 스레드에게 기회를 준다.

 

    private int amount;
    private int interest;
 
    public CommonCalc() {
        amount = 0;
        interest = 0;
    }
    
    private Object interestLock = new Object();
    private Object amountLock   = new Object();
    
    public void plus(int value) {
        synchronized (amountLock) {
            amount += value;
        }
    }    
    
    public void addInterest(int value) {
        synchronized (interestLock) {
            interest += value;
        }
    }

 

때에 따라서 위의 코드처럼 amount, interest 두 개의 변수 모두 여러 스레드가 접근하면 안 되는 경우가 발생할 수 있다. 이럴 때 lock이라는 하나의 잠금용 객체만 사용하면 amount라는 변수를 처리할 때, interest라는 변수를 처리하려는 부분도 처리를 못하게 된다. 따라서, 두 개의 별도의 lock 객체를 사용하면 효율적인 프로그램이 된다.

 

🚀  마무리

여기까지 자바 스레드를 들어가기에 앞서 개념을 살펴보았고 스레드에 대해서 대략적으로 살펴보았다 물론 이외에도 다양한 메서드를 지원한다. 하지만 블로깅 목적은 스레드의 큰 틀과 메커니즘을 이해하고 대략적인 부분을 코드로 살펴보고자 이렇게 글을 썼다. 2편에서는 스레드 상태 정보 관련해서 알아볼 예정이다.

 

 

출처: 

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

- [교재] 자바의신 (이상민 저)
- https://yoonemong.tistory.com/216 [Sw.Dev]

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

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