Thread - 멀티쓰레드 프로그래밍

자바 라이브 스터디 10주 차 - 멀티스레드 프로그래밍

---

❓자바에서 스레드를 사용하는 이유와 스레드를 생성하는 방법

프로그램에서 어떠한 작업을 하기 위해서는 프로세스가 시작되며, 동시에 여러 일을 처리하기 위해 여러 개의 프로세스가 시작된다. 하지만 프로세스 하나가 시작되려면 많은 자원(약 32MB ~ 64MB)이 할당된다. 그에 반해 스레드는 하나당 1MB 정도 할당되므로 자바에서는 여러 작업을 적은 자원으로 작업을 수행하기 위해 스레드를 사용한다.

1. Process & Thread

https://mohanma.com/difference-process-thread-java/

프로세스

• 단순히 실행 중인 프로그램, 사용자가 작성한 프로그램이 운영체제에 의해 메모리 공간을 할당받아 실행 중인 것
• 프로세스는 프로그램에서 사용되는 데이터, 메모리, 스레드로 구성됨
• 최소 하나의 스레드로 구성되어있으며 두 개 이상일 경우 멀티 스레드 프로세스

스레드

• 프로세스 내에서 실제로 작업을 수행하는 주체, 실제 실행이 되는 단위, 스레드가 cpu를 점유해서 스레드 작업 수행 ( 스케쥴러에 의해 cpu 점유 )
• 모든 프로세스에는 한 개 이상의 스레드가 존재하여 작업 수행

비유하자면 프로세스는 공장, 스레드는 공장에서 일하는 일꾼 비유하면 이해가 빠를 것 같다.

---

2. Thread 생성 방법 - Thread 클래스와 Runnable 인터페이스

두 가지 방법은 인스턴스 생성 방법이 다르다.

2.1 인터페이스 Runnable 구현

자바는 다중 상속이 허용되지 않으므로 이미 다른 클래스를 상속한 경우 thread를 생성하려면 runnable 인터페이스를 구현하여 Thread를 생성한다.

  1. Runnable 인터페이스를 구현한 클래스의 인스턴스 생성

  2. 인스턴스를 Thread 생성자의 매개변수로 제공한다.

class AnyThread implements Runnable {
	public void run(){
  }

public static void main(String args[]) {
		AnyThread test = new AnyThread();     // Thread 클래스 객체를 생성하여
		Thread myThread = new Thread(test);   // 쓰레드의 타겟에 넣어 사용
		myThread.start(); //실행 방법은 start() 호출
	}
}

2.2 Thread 클래스 상속

extends키워드로는 하나의 클래스만 상속이 가능

class AnyThread extends Thread {
	public void run(){
  }

public static void main(String args[]) {
		AnyThread test = new AnyThread();         
		test.start();
	}
}

→ 스레드를 통해 작업하고 싶은 내용 run() 메서드에 구현

→ start() 메서드로 스레드 시작

 

Thread의 실행 - start()

스레드 생성 후 start() 메서드로 스레드를 실행시킨다. 바로 실행되는 것은 아니고 실행 대기 상태였다가 자기 차례가 되었을 때 차례로 실행한다. ( 실행 순서는 os의 스케쥴러에 의해 결정된다. )

한번 실행이 완료된 스레드는 다시 실행이 불가하다.

다시 실행하려면 아래와 같이 새로운 스레드를 생성해서 실행해야 한다.

→ start()는 프로세스가 아닌 스레드가 JVM에 추가되어 실행됨을 뜻한다.

class AnyThread extends Thread {
	public void run(){
    
  }

public static void main(String args[]) {
	AnyThread test = new AnyThread();         
	test.start();
        
        test = = new AnyThread(); // 다시 생성
        test.start();
 }	
}

 

♨ 스레드를 생성시킬 때 run() 메서드가 아닌 start() 메서드를 호출할까?

 

 

---

3. Single Thread & Multi Thread

싱글 스레드 프로그래밍

스레드 하나로 수행되는 프로그래밍. 대표적인 예시로 main메서도 하나로 수행되는 프로그래밍이다.

 

멀티스레드 프로그래밍

동시에 여러 개의 스레드가 수행되는 프로그래밍

 

멀티스레드 프로그래밍의 경우 여러 스레드가 같은 프로세스 내의 자원을 공유해서 작업하므로, 서로의 작업에 영향을 줄 수 있다. 이를 방지하기 위해 임계 영역(critical section), 락(lock)이라는 개념이 나왔다.

 

스레드는 각각의 작업공간(context)을 가진다. 스레드들이 공유하는 자원이 있는 경우 race condition이 발생, 자원의 영역을 critical section(임계 영역)이라 한다. 두 개의 스레드가 동시에 접근한다면 아래와 같은 경우가 발생할 수 있다.

 

예시) 스레드 a가 두 개의 값을 더하는 작업 중이었는데 스레드 b가 동일한 공유자원을 빼는 연산으로 오버 라이딩되어 스레드 a의 연산이 무시될 수 도 있다.

 

임계 영역 (critical section)

두 개 이상의 스레드가 동시에 접근하게 되는 리소스

critical section에 동시에 thread가 접근하게 되면 실행결과를 보장할 수 없음

스레드 간의 순서를 맞추는 동기화(synchronization)가 필요

잠금 (lock) 

critical section에 접근할 수 있는 스레드는 한 개뿐으로 제한하고 다른 스레드가 접근할 수없도록 제한하는 것

---

4. Thread의 상태

https://knpcode.com/java/multi-threading/thread-states-in-java-thread-life-cycle/

자바 doc에 나와있는 thread 상태 https://docs.oracle.com/javase/7/docs/api/java/lang/Thread.State.html

 

상태	설명
NEW	쓰레드는 생성되었지만 아직 start()로 실행되지 않은 상태
RUNNABLE	start()메서드에 의해 쓰레드 객체가 호출, 실행중이거나 실행 가능한 상태 JVM에의해 실행되도록 예약되었지만 CPU cycle을 얻기 전까지 실행되지 않을수도있다.
BLOCKED	동기화 블럭에 의해서 일시정지된상태 ( lock이 풀릴때까지 기다리는 상태 )
WAITING	쓰레드의 작업이 종료되지않았지만 실행가능하지 않은 상태, 일시정지한 상태  Object.wait(), Thread.join(), sleep 메서드등에의해 WAITING 상태가 됨
TIME_WAITING	셋팅된 시간만큼 대기중인 상태, 이와 같은 메서드에 의해 TIME_WAITING 상태가 될 수 있다. Thread.sleep Object.wait with timeout Thread.join with timeout LockSupport.parkNanos LockSupport.parkUntil
TERMINATED	쓰레드의 작업이 종료된 상태

---

5. Thread의 우선순위

스레드는 우선순위 (priority)라는 속성 멤버 변수를 가진다.

Thread의 우선순위를 다르게 지정하여 특정 스레드가 더 많은 작업 시간을 갖도록 조정 가능하다.

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

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

int getPriority() //스레드의 우선순위 반환

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

setPriority(int newPriority) 스레드의 우선순위를 지정한 값으로 변경

 

Thread.MIN_PRIORITY(=1) ~ Thread.MAX_PRIORITY(=10)

디폴트 우선순위 : Thread.NORM_PRIORITY(=5)

Thread의 우선순위는 스레드를 생성한 스레드로부터 상속받는 것! 

-> main 메서드를 수행하는 스레드는 priority(5) 이므로 main 메서드 내에서 생성하는 Thread는 자동적으로 우선순위 5가 된다.

우선순위가 높은 thread는 CPU를 배분받을 확률이 높음

---

6. Thread의 메서드

6.1 join 메서드

다른 스레드의 작업을 기다린다.

다른 스레드의 결과를 보고 진행해야 하는 일이 있는 경우 join메서드 활용한다.

아래 그림에서 join() 메서드를 호출한 스레드가 non-runnable 상태가 된다. thread2가 시작되고 thread2가 죽으면 thread1 작업을 다시 수행하게 된다.

join() 메서드에 시간을 세팅하지 않는다면 기다리면서 수행할 작업이 모두 끝날 때까지 기다린다.

* sleep()와 차이점으로 join()은 현재 스레드가 아닌 특정 스레드에만 적용되므로 static메서드가 아니다.

package thread;

public class JoinTest extends Thread {

    int start;
    int end;
    int total;

    public JoinTest(int start, int end){
        this.start = start;
        this.end = end;
    }

    public void run(){
        int i;
        for (i=start; i<=end; i++){
            total += i;
        }

    }
    public static void main(String[] args) {

        JoinTest jt1 = new JoinTest(1,50);
        JoinTest jt2 = new JoinTest(51,100);

        jt1.start();
        jt2.start();

        int total = jt1.total + jt2.total;//여기서는 제대로 계산되지 않음
        System.out.println("jt1.total = "+ jt1.total);
        System.out.println("jt2.total = "+ jt2.total);//두개의 결과값이 같지 않은건 join
        System.out.println(total);

    }
}

메인 스레드에서 작업되는 total계산이 jt1, jt2스레드의 작업이 모두 종료된 후가 아니므로 total의 값이 이상하다.

아래 코드는 메인 스레드에서 jt1, jt2 스레드에 join을 걸었다.

package thread;

public class JoinTest extends Thread {

    int start;
    int end;
    int total;

    public JoinTest(int start, int end){
        this.start = start;
        this.end = end;
    }

    public void run(){
        int i;
        for (i=start; i<=end; i++){
            total += i;
        }

    }
    public static void main(String[] args) {

        JoinTest jt1 = new JoinTest(1,50);
        JoinTest jt2 = new JoinTest(51,100);

        jt1.start();
        jt2.start();


        try {
            jt1.join();
            jt2.join();

            //main쓰레드가 jt1,jt2에 join을 걸었다.
            //try-catch 블럭이 잠시 기다렸다가
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        int total = jt1.total + jt2.total;//여기서는 제대로 계산되지 않음

        System.out.println("jt1.total = "+ jt1.total);
        System.out.println("jt2.total = "+ jt2.total);//여기서는 제대로 계

        System.out.println(total);

    }
}

6.2 wait() / notify() / notifyAll()

아래 메서드는 자바 최상이 클래스인 Object 클래스에 정의되어있다.

동기화 블록 안에서만 사용이 가능하다.

wait()	리소스의 사용이 유효하지않을때 리소스 사용이 가능할 때까지 thread가 lock을 반납하고 대기상태가 된다.(non-runnable한 상태로 전환)
notify()	wait()하고있는 thread중 임의의 쓰레드를 꺠운다. (runnable한 상태로 변경)
notifyAll()	wait() 하고있는 모든 thread를 깨운다. notify()보다 notifyAll() 을 권장한다. 특정 thread를 깨우는 제어를 할 수 없으므로 모두 깨운 후 경쟁시킨다. 경쟁 후 하나의 thread만 lock을 얻고 얻지 못한 thread는 다시 wait() 상태가 된다.

아래 코드는 책이라는 자원은 한정적인데 대여자가 많아 대기열이 생겼을 때이다.

책이 다시 반납되었을 경우 notifyAll()을 사용하여 thread가 깨어나 경쟁하여 책을 가져가도록 한다.

package thread;
import java.util.ArrayList;

class FastLibrary{
    public ArrayList<String> books = new ArrayList();

    public FastLibrary(){
        books.add("태백산맥1");
        books.add("태백산맥2");
        books.add("태백산맥3");
    }

    public synchronized String lendBook() throws InterruptedException {

        Thread t = Thread.currentThread();
        while(books.size() == 0) {//경쟁 후 책이 없으면 다시 잠들도록
            //책이 들어올때까지 대기
            System.out.println(t.getName()+" waiting start");
            wait();
            System.out.println(t.getName()+" waiting stop");
        }
        String title = books.remove(0);

        System.out.println(t.getName() +":"+title+" lend");

        return title;

    }

    public synchronized void returnBook(String title){
        Thread t = Thread.currentThread();
        books.add(title);
        notifyAll();//모든 스레드가 깨어나서 경쟁하도록 공정하게
        System.out.println(t.getName() +":"+title+" return");

    }
}

class Student extends Thread{
    public void run(){
        try {
            String title = LibraryMain.library.lendBook();
            if(title == null) return;
            sleep(5000);
            LibraryMain.library.returnBook(title);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}


public class LibraryMain {

    public static FastLibrary library = new FastLibrary();//shared resource
    //리소스는 한정적이고 리소스를 쓸려고하는 쓰레드는 많을 경우

    public static void main(String[] args) {

        Student student1 = new Student();
        Student student2 = new Student();
        Student student3 = new Student();
        Student student4 = new Student();
        Student student5 = new Student();
        Student student6 = new Student();

        student1.start();
        student2.start();
        student3.start();
        student4.start();
        student5.start();
        student6.start();

    }
}

 

---

7. Main Thread

JVM에 의해 자동으로 생성된다.

main메서드는 프로그램 실행의 시작점

jvm에 프로그램을 실행시키면서 main 스레드를 자동 생성하고 프로그램이 실행된다.(main 스레드)

package thread;

public class HelloWorldTest {
    public static void main(String[] args) {
        int[] num = {1,2,3};
        System.out.println(num[4]);
        System.out.println("Hello World");
    }
}

클래스를 생성하고 main 메서드에서 배열의 값을 출력하는 코드를 작성하였다. 일부러 exception을 발생시키고 현재 스레드를 확인하였다.

아래 화면을 보면 스레드의 이름이 main 임을 확인할 수 있다.

JVM이 메인 스레드를 자동으로 만들지만  다른 스레드처럼  스레드 명칭을 수정할 수 있다. 

package thread;

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

        Thread obj = Thread.currentThread();//Thread객체로 부터 현재 쓰레드 정보 받기
        System.out.println("Name of thread : "+obj.getName());
        System.out.println("Priority of thread : "+obj.getPriority());

        obj.setName("Hello Main Thread");
        System.out.println("New Name of thread : "+ obj.getName());
        System.out.print("Hello World");
    }
}

다른 스레드를 생성한다.

main 스레드에서 다른 스레드들이 생성되어 마치 main스레드의 자식 스레드처럼 볼 수 있다.

main 스레드의 우선순위가 5이므로 메인 스레드에서 생성된 스레드도 동일하게 디폴트 우선순위(5)를 가지게 된다.

데몬 스레드

• 데몬(Daemon)이란 보통 리눅스나 유닉스 계열의 운영체제에서 백그라운드로 동작하는 프로그램을 말한다. 윈도 계열에서는 서비스라고 함
• 자바 프로그램 작성 시 백그라운드에서 특별한 작업을 처리하게 하는 용도로 사용한다.
• 일반 스레드(main 등이) 모두 종료되면 데몬 스레드는 강제적으로 자동 종료된다.
• 데몬 스레드 예시 ) 가비지 컬렉터, 워드프로세서의 자동 저장, 화면 자동 갱신

→ 3초마다 autoSave값을 확인하여 자동 저장 메서드를 호출하도록 데몬 스레드를 생성하였다.

package thread;

public class DaemonThreadTest implements Runnable{
    static boolean autoSave = false;

    public static void main(String[] args) {
        Thread t = new Thread(new DaemonThreadTest());
        t.setDaemon(true);//true로 설정 시 데몬쓰레드로 설정
        t.start();

        for (int i=1; i<=10; i++){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {

            }

            System.out.println(i);
            if(i == 5){
                autoSave = true;
            }
        }
        System.out.println("프로그램을 종료합니다.");
    }

    @Override
    public void run() {
        while(true){
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {

            }
                if(autoSave){
                    autoSave();
                }

        }
    }

    public void autoSave() {
        System.out.println("작업파일이 자동저장되었습니다. ");
    }
}

데몬 스레드 설정은 start메서드보다 먼저 수행되어야 한다. 만약 먼저 실행되지 않으면 IllegalThreadStateException이 발생한다.

데몬 스레드는 백그라운드로 특별한 작업을 수행하는데 데몬을 설정하는 것 자체가 도울 스레드가 이미 시작한 뒤에 설정하는 것은 말이 되지 않기 때문인 것 같다.

IllegalThreadStateException은 thread가 살아있는지 확인 후 죽어있으면 exception을 날린다.

 

여기서 스레드의 살아있음 유무는 시작되었는지와 아직 죽지 않은 상태를 뜻한다.

---

8. 동기화 ( Synchronized )

한 스레드의 작업을 다른 스레드가 간섭하지 못하게 막는 것을 동기화 ( 영역에 대한 순서를 지키자 synchronization) 라 한다.

동기화를 잘못 구현하면 deadlock에 빠질 수 있다.

synchronized 키워드는 하나의 스레드만 지정된 영역의 코드를 하나의 스레드가 수행할 수 있도록 보장하는 것이다.

 

아래 예제에서 동기화되지 않았을 때 어떤 현상이 나타나는지 확인하자.

class bank{//critical section 쉐어는 되었지만 동기화가 되지 않았다.
    private int money = 10000;
    
    public void saveMoney(int save){
        int m = getMoney();

        try {
            Thread.sleep(3000);//저축되는 시간
           
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        setMoney(m+save);
    }

    public void minusMoney(int minus){
        int m = getMoney();

        try {
            Thread.sleep(200);//인출되는 시간
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        setMoney(m-minus);
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}

class park extends Thread{
    public void run() {    
        
        SyncTest.myBank.saveMoney(3000);
        System.out.println("save money : " + SyncTest.myBank.getMoney());

    }
}


class parkWife extends Thread{
    public void run() {
        SyncTest.myBank.minusMoney(1000);
        System.out.println("minus money : " + SyncTest.myBank.getMoney());
    }
    //이 run메서드아래에서 락을 걸 경우 save가 다 완료되고나서 minus가 수행된다
}


public class SyncTest  {

    public static bank myBank = new bank();

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

        park p = new park();
        p.start();
        //먼저일을 시작한 사람이 park씨 이므로 park 씨의 일이 끝날때까지 pw의 일은 시작되지 않음

        Thread.sleep(200);

        parkWife pw = new parkWife();
        pw.start();
    }

}

박 씨의 작업 스레드(save)가 먼저 실행되어 13000원이 적금된 뒤 박 씨 와이프의 작업 스레드(minus)가 수행되어 12000원의 잔고가 남아있을 거라 예상되었지만 수행 결과는 달랐다.

이는 접근하는 리소스에 대한 동기화( 자원에 접근하는 순서가 지켜지는 것)가 되지 않아 위와 같은 결과가 발생하였다.

자바에서 동기화 구현 방식

1. synchronized 수행문 - 메서드 내의 일부를 임계 영역으로 지정

객체의 참조 변수는 lock을 걸고자 하는 객체를 참조

synchronized(객체의 참조변수){
 // 참조형 수식에 해당되는 객체에 lock를 건다.
}

[예제]

package thread;

class bank{
    private int money = 10000;

    public void saveMoney(int save){
        int m = getMoney();

        try {
            Thread.sleep(3000);
            
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        setMoney(m+save);

    }

    public void minusMoney(int minus){
        int m = getMoney();

        try {
            Thread.sleep(200);//저축되는 시간
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        setMoney(m-minus);
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}

class park extends Thread{
    public void run() {
       synchronized (SyncTest.myBank) {
        SyncTest.myBank.saveMoney(3000);
        System.out.println("save money : " + SyncTest.myBank.getMoney());
       }

    }
}


class parkWife extends Thread{
    public void run() {
        synchronized (SyncTest.myBank) {
        SyncTest.myBank.minusMoney(1000);
        System.out.println("minus money : " + SyncTest.myBank.getMoney());
    }
    }
}


public class SyncTest  {

    public static bank myBank = new bank();

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

        park p = new park();
        p.start();
        Thread.sleep(200);

        parkWife pw = new parkWife();
        pw.start();
    }
}

 

2. synchronized 메서드 - 메서드 전체를 임계 영역으로 지정

public synchronized void test(){
}

스레드는 synchronized 메서드가 호출된 시점부터 해당 메서드가 포함된 객체의 lock을 얻어 작업을 수행하다가 메서드가 종료되면 lock을 반환한다.

 

임계 영역의 인스턴수 변수 접근 제어자는 외부에서 접근하지 못하도록 private로 선언해야 한다.

[예제]

package thread;

class bank{
    private int money = 10000;


    //메서드가 속한 객체에 lock이 걸림, 이 메서드가 수행될때는 다른 메서드가 bank 객체에 접근이 불가함
    public synchronized void saveMoney(int save){
        int m = getMoney();

        try {
            Thread.sleep(3000);
            
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        setMoney(m+save);
 
    }

    public synchronized void minusMoney(int minus){
        int m = getMoney();

        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        setMoney(m-minus);
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}

class park extends Thread{
    public void run() {
        SyncTest.myBank.saveMoney(3000);
        System.out.println("save money : " + SyncTest.myBank.getMoney());
    }
}


class parkWife extends Thread{
    public void run() {
        SyncTest.myBank.minusMoney(1000);
        System.out.println("minus money : " + SyncTest.myBank.getMoney());
    }
}


public class SyncTest  {

    public static bank myBank = new bank();

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

        park p = new park();
        p.start();

        Thread.sleep(200);

        parkWife pw = new parkWife();
        pw.start();
    }

}

---

9. 데드락 ( = 교착 상태 )

여러 스레드가 같은 프로세스 내에서 자원을 점유한 상태에서 서로 상대편이 점유한 자원을 사용하려고 기다리느라 작업의 진행이 멈춘 상태

두 개 이상의 스레드가 서로 기다리는 상황

L1이 잠그고 풀리려면 L2가 필요, L2을 잠그고 풀려면 L1이 필요하다. 하지만 L1이 잠겨있는 상태이므로 무기한으로 대기 중인 상태로 빠지게 된다.

패스트캠퍼스 - 자바 올인원 박은종 강사님

 

 

---

[참고]

www.javamadesoeasy.com/2015/03/thread-states-thread-life-cycle-in-java.html

javagoal.com/main-thread-in-java/ 

main thread in java and How does main thread in java - JavaGoal

패스트 캠퍼스 - 자바 올인원 패키지 - 박은종 강사님

자바의 정석 - 스레드 참고

자바의 신 - 스레드 참고

programmers.co.kr/learn/courses/9/lessons/279