Java Thread

 

1. 스레드(Thread)란?

- 어떤 프로세스 내에서 실행되는 흐름(작업)의 단위다.

- 프로세스 내 명령어 블록으로 시작, 종료점을 가진다.

1. JVM에 의해 하나의 프로세스가 발생하고 main 내부의 실행문이 하나의 스레드다.
2. main() 이외에 다른 스레드를 만들려면 Thread 클래스를 상속하거나 Runnalble 인터페이스를 구현한다.
3. 다중 스레드 작업 시 각 스레드끼리 정보를 주고받을 수 있어 처리 과정의 오류를 줄일 수 있다.
4. 프로세스끼리는 정보를 주고받을 수 없다.

 

2. 멀티스레딩이란?

여러 스레드를 동시에 실행시키는 응용프로그램을 작성하는 기법이다.

 

  장점

• 메모리 공유로 인한 시스템 자원 소모가 줄어든다.

• 동시에 두 가지 활동을 하는 것이 가능해진다.

  단점

• 서로 자원을 소모하다가 충돌이 일어날 가능성이 존재한다.

• 코드가 난해해져 버그생성확률이 높아진다.

 

3. 스레드 생성주기

출처 : https://promobile.tistory.com/213

New : 인스턴스는 만들어졌으나 아직 실행이 되지 않은 상태

Runnable (준비상태) : start() 메소드 호출에 의해 스레드는 Runnable 상태로 이동한다.

Running (실행상태) : 스케줄러는 Runnable pool 체크하고 스레드를 Running 상태로 이동시킨다.

Blocked (지연상태) : sleep(), wait() 메소드, I/O 입출력 요청, 대기상태로 이동한다.

Dead (종료상태) : 실행이 완료되면 스레드는 종료되고 이 상태에서 다시 시작되는것은 불가능하다.

 

 

4. synchronized

 

<메소드를 synchronized로 선언>

synchronized가 메소드 선언부에 있으면 해당 객체의 메소드에 2개의 쓰레드가 접근하든, 100개의 쓰레드가 접근하든 간에 한 순간에는 하나의 쓰레드만 이 메소드를 수행하게 된다.

• CommonCalculate 클래스의 객체를 calc라는 이름으로 생성
• ModifyAmountThread라는 클래스 객체를 생성할 때 calc를 매개변수로 넘기고 plus() 메소드만 수행하도록 true를 두번째 매개변수로 넘김
• 각각의 스레드 실행
• try-catch 블록 안에서 join()이라는 메소드를 각각의 스레드에 대해 호출한다. [join : 스레드가 종료될 때까지 기다리는 메소드]
• join()이 끝나면 calc 객체의 getAmount() 메소드를 호출한다. getAmount() 메소드의 호출 결과는 join() 메소드 수행 이후이므로 모든 스레드가 종료된 이후의 결과다.

<아래 코드의 결과 예상>

Main 클래스의 runCommonCalculate() 메소드가 수행된 후 두개의 스레드에서 하나의 객체에 있는 amount라는 int 타입의 값에 1을 만번 더해 20000이 출력되어야한다.

public class Main {
    public static void main(String[] args) {
        Main runSync=new Main();
        for (int i = 0; i < 5; i++)
            runSync.runCommonCalculate();
    }

    public void runCommonCalculate() {
        CommonCalculate calc=new CommonCalculate();
        ModifyAmountThread thread1 = new ModifyAmountThread(calc,true);
        ModifyAmountThread thread2 = new ModifyAmountThread(calc,true);

        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
            System.out.println("Final value is "+calc.getAmount());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class CommonCalculate {
    private int amount;
    public CommonCalculate() {
        amount = 0;
    }
    public void plus(int value) {
        amount += value;
    }
    public void minus(int value) {
        amount -= value;
    }
    public int getAmount() {
        return amount;
    }

}

public class ModifyAmountThread extends Thread {
    private CommonCalculate calc;
    private boolean addFlag;
    public ModifyAmountThread(CommonCalculate calc, boolean addFlag){
        this.calc=calc;
        this.addFlag=addFlag;
    }
    public void run() {
        for (int loop = 0; loop < 10000; loop++) {
            if(addFlag) {
                calc.plus(1);
            } else {
                calc.minus(1);
            }
        }
    }
}

하지만 결과는 다음과 같이 나온다.
Final value is 20000

Final value is 17824

Final value is 14589

Final value is 19747

Final value is 20000

 

20000이 나올때도, 나오지 않을때도 있다.

 

<왜 이런 현상이 일어나는가?>

plus()메소드는 다른 쓰레드에서 작업하고 있더라도, 새로운 스레드에서 온 작업도 같이 처리하기 때문에 데이터가 꼬일 수 있다.

은행창구를 예로들면 한명의 직원이 하나의 창구에서 한 고객의 요청만 처리하는데, 만약 한번에 여러 고객의 요청을 처리하면 해당 창구는 고객의 요청이 뒤죽박죽 되어 한건도 제대로 처리 못하게 될 수 있다.

 

아래처럼 synchronized를 plus() 메소드에 추가해주면 앞선 스레드에서 수행하고있는 메소드가 끝날 때 까지 늦게온 스레드는 기다리게 된다.

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

 

메소드에 추가하는 방법이 아닌 다음과 같은 방법도 존재한다.

이렇게 synchronized를 추가해주면 대기시간을 효율적으로 관리할 수 있다.

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

 

 

4. 예제

 

1. Single Thread (extends Thread)

import java.util.*;

public class SingleTreadEx extends Thread  {
    private int[] temp;
    public SingleTreadEx(String threadname) {
        super(threadname);
        temp = new int[10];

        for (int start=0; start<temp.length; start++) {
            temp[start]=start;
        }
    }

    public void run() {
        for (int start:temp) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException ie) {
                ie.printStackTrace();
            }
            System.out.println("Thread Name :"+currentThread().getName());
            System.out.println("temp value :"+start);
        }
    }

    public static void main(String[] args) {
        SingleTreadEx st = new SingleTreadEx("1번 스레드");
        st.start();
    }
}

2. Single Thread (implements Runnable)

public class SingleTreadEx implements Runnable {

    private int[] temp;

    public SingleTreadEx(){
        temp = new int[10];

        for(int start=0;start<temp.length;start++){
            temp[start]=start;
        }
    }

    @Override
    public void run() {
        for(int start:temp){
            try {
                Thread.sleep(1000);

            } catch (InterruptedException ie) {
                ie.printStackTrace();
            }

            System.out.println("Thread Name :"+Thread.currentThread().getName());
            System.out.println("temp value :"+start);
        }
    }

    public static void main(String[] args) {

        SingleTreadEx ct = new SingleTreadEx();
        Thread t = new Thread(ct,"1번 스레드");

        t.start();
    }
}

3. Multi Thread

class ATM implements Runnable {
    private long depositeMoney = 10000;

    public void run() {
        synchronized (this) {

            for (int i = 0; i < 10; i++) {
                notify();
                try {
                    wait();
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (getDepositeMoney() <= 0)
                    break;
                withDraw(1000);
            }
        }
    }

    public void withDraw(long howMuch) {
        if (getDepositeMoney() > 0) {
            depositeMoney -= howMuch;
            System.out.print(Thread.currentThread().getName() + " , ");
            System.out.printf("잔액 : %,d 원 %n", getDepositeMoney());
        } else {
            System.out.print(Thread.currentThread().getName() + " , ");
            System.out.println("잔액이 부족합니다.");
        }
    }

    public long getDepositeMoney() {
        return depositeMoney;
    }
}


public class SynchronizedEx {
    public static void main(String[] args) {
        ATM atm = new ATM();
        Thread mother = new Thread(atm, "Junho");
        Thread son = new Thread(atm, "Wonbeen");
        mother.start();
        son.start();
    }
}

 

 

*Reference

이상민 / 자바의 신 vol.1 / 로드북 / 2013년 2월

https://coding-factory.tistory.com/279

https://jdm.kr/blog/69

https://raccoonjy.tistory.com/15