자바(Java) - Thread(멀티 스레드)

🗄️ Backend/Java

자바(Java) - Thread(멀티 스레드)

kongmi 2023. 2. 2. 20:34

멀티 스레드(Multi Thread)?

하나의 프로그램에서 여러가지 일을 동시에 수행하는 것

When code running in some thread creates a new Thread object, the new thread has its priority initially set equal to the priority of the creating thread, and is a daemon thread if and only if the creating thread is a daemon.

Main Thread

💡모든 자바 어플리케이션은 Main Thread가 main() 메소드를 실행하면서 시작됩니다.

💡스레드는 운영체제가 실행시키기 때문에 약간의 텀이 있음

싱글 스레드는 메인 스레드가 종료되면 프로세스도 종료되지만,

멀티 스레드는 메인 스레드가 종료되더라도 실행 중인 스레드가 하나라도 있다면 프로세스는 종료되지 않습니다.

Thread 생성

There are two ways to create a new thread of execution. One is to declare a class to be a subclass of Thread. 💡This subclass should override the run method of class Thread. An instance of the subclass can then be allocated and started.

Thread 클래스 상속

🚨제일 쉬운 방법이지만 좋은 방법은 아님. 다른 클래스 상속을 못 받음

public class Main {
    public static void main(String[] args) {
        Thread test = new TestThread();
        test.start();
        int sum = 0;

        for (int i = 0; i <= 100; i++) {
            sum += i;
            System.out.println("여기는 메인 스레드 입니다." + sum);
        }
        System.out.println(Thread.currentThread() + "합계 : " + sum);
    }
}

class TestThread extends Thread {
    @Override
    public void run() {
        int sum = 0;
        for(int i = 0; i <= 100; i++) {
            sum += i;
            System.out.println("여기는 테스트 스레드 입니다. : " + sum);
        }
        System.out.println(Thread.currentThread() + "합계 : " + sum);
    }
}

Runnable 인터페이스 구현

new를 통해 Thread 클래스 객체를 생성 후 start() 메소드를 통해 다른 스레드에서 할 작업을 할당하는 방법

Thread 객체를 생성할 때는 Runnable 인터페이스를 구현한 클래스 객체를 매개변수로 받습니다.
start() 메소드를 호출하면 작업 스레드는 자신의 run() 메소드를 실행 합니다.

import static java.lang.Thread.sleep;

public class RunThread implements Runnable {
    @Override
    public void run() {
        int sum = 0;
        for(int i = 0; i < 5; i++) {
            sum += i;
            try {
                sleep(1);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("" + Thread.currentThread() + sum);
        }
        System.out.println(Thread.currentThread() + " 합계 : " + sum);
    }
}

public class Main {
    public static void main(String[] args) {
    	Runnable runTh = new RunThread();
        Thread th1 = new Thread(runTh);
        runTh1.start();
        
        Runnable runTh2 = new RunThread();
        Thread th2 = new Thread(runTh2);
        runTh2.start();
    }
}

Runnabe runTh = new RunThread();
수행해야 할 작업 내용은 포함하고 있지만 실제 스레드는 아니기 때문에 Thread 객체를 생성시 Runnable 인터페이스를 구현한 클래스의 객체를 넣어준 후 start() 해야 한다.

Thread[Thread-0,5,main]0
Thread[Thread-1,5,main]0
Thread[Thread-0,5,main]1
Thread[Thread-1,5,main]1
Thread[Thread-1,5,main]3
Thread[Thread-0,5,main]3
Thread[Thread-0,5,main]6
Thread[Thread-1,5,main]6
Thread[Thread-1,5,main]10
Thread[Thread-0,5,main]10
Thread[Thread-1,5,main] 합계 : 10
Thread[Thread-0,5,main] 합계 : 10

익명의 객체 생성 (일회용)

Runnable task = new Runnable() {
            @Override
            public void run() {
                int sum = 0;
                for(int i = 0 ; i < 10; i++) {
                    sum += i;
                    System.out.println("" + Thread.currentThread() + sum);
                }
                System.out.println(Thread.currentThread() + " 합계 : " + sum);
            }
        }; // 구현부의 끝이다 의미로 ';' 붙여야 함.
        Thread runTh3 = new Thread(task);
        runTh3.start();

익명의 객체를 람다식으로 생성

Runnable task2 = () -> {
            int sum = 0;
            for(int i = 0 ; i < 10; i++) {
                sum += i;
                System.out.println("" + Thread.currentThread() + sum);
            }
            System.out.println(Thread.currentThread() + " 합계 : " + sum);
        };
        Thread runTh4 = new Thread(task2);
        runTh4.start();

        System.out.println("나는 main 입니다.");

Thread 우선 순위

우선 순위(Priority) 방식

우선 순위가 높은 스레드가 실행을 더 많이 하도록 스케줄링 하는 방법

thread.setPriority(1) : 우선 순위 가장 낮음
thread.setPriority(10) : 우선 순위 가장 높음

순환 할당 방식

시간 할당량을 정해서 하나의 스레드를 정해진 시간만큼만 실행하는 방법
해당 방식은 JVM 안에서 이루어지기 때문에 개발자가 제어할 수 없음.

Thread 상태

스레드로 객체를 생성하면 우선 실행 대기 상태로 들어갑니다.

실행대기 상태란 코어에서 작업을 할당받지 못한 상태 입니다.

실행 대기 상태에 있는 스레드 중 스레드 스케줄링으로 선택된 스레드가 CPU를 점유하고 운영체제가 run()을 실행 합니다.

이 때 CPU를 점유하고 있는 상태가 실행 상태 입니다.

run() 메소드가 끝나지 않아도 스레드 스케줄링에 의해 다시 실행 대기 상태로 돌아가며 번갈아 가면서 내용을 끝낼 때까지 지속합니다.

경우에 따라 run() 메소드가 실행중인 스레드를 일시 정지 시킬 수도 있는데 일시 정지 후에는 다시 실행 대기 상태로 갑니다.

Thread 상태 제어

실행 중인 스레드 상태를 변경하는 것을 스레드 상태 제어라고 합니다.
멀티 프로그램을 만들기 위해서는 정교한 스레드 상태 제어가 필요합니다.

메소드	설명
interrupt()	일시 정지 상태의 스레드에서 interruptException 예외를 발생시켜, 예외 처리 코드
notify(), notifyAll()	동기화 블록 내에서 wait() 메소드에 의해 일시 정지 상태에 있는 스레드를 실행 대기 상태로 만듬
sleep()	주어진 시간 동안 스레드를 일시 정지 상태로 만듬
join()	join() 메소드를 호출한 스레드는 일시 정지 상태가 된다. 실행 대기 상태로 가려면 join() 메소드를 멤버로 가진 스레드가 종료 되거나, 매개값으로 주어진 시간이 지나야 함
wait()	동기화 블록 내에서 스레드를 일시 정지 상태로 만듬 * 매개변수가 주어지면 주어진 시간이 지나면 자동으로 실행 대기 상태가 됨. * 시간이 주어지지 않으면 notify(), notifyAll() 메소드에 의해 실행 대기 상태로 전환

주어진 시간 동안 일시 정지(sleep())

실행중인 스레드를 일정 시간동안 대기 상태로 만듬
반복 수행에 대한 시간을 늦출 때 사용하거나, 인터럽트 예외처리를 위해서 사용

import java.awt.*;
import static java.lang.Thread.sleep;

public class Main {
    public static void main(String[] args) {
        Toolkit toolkit = Toolkit.getDefaultToolkit();
        for(int i = 0; i < 10; i++) {
            toolkit.beep();
            try {
                sleep(3000);
            } catch (InterruptedException e) {
            }
        }
    }
}

3초 주기로 10번 비프음 발생하는 코드

다른 스레드의 종료를 기다림(join())

다른 스레드가 종료될 때 까지 기다렸다가 실행해야 하는 경우에 사용
예) 예를 들어 계산 작업을 하는 스레드가 모든 계산을 마치고 결과값을 받아 이용해야 하는 경우

🐶 join() 사용 전

public class Main {
    public static void main(String[] args) {
       SumTh sumTh = new SumTh();
       sumTh.start();
       
       System.out.println("합 : " + sumTh.getSum());
    }
}

class SumTh extends Thread {
    private long sum;

    public long getSum() {
        return sum;
    }

    public void setSum(long sum) {
        this.sum = sum;
    }

    @Override
    public void run() {
        for(int i = 0; i < 100; i++) {
            sum += 1;
            try {
                sleep(1);
            } catch (InterruptedException e) {}
        }
    }
}

합 : 0

Thread가 실행 되기 까지 시간보다 main에서 getSum() 실행하는 시간이 훨씬 빠르기 때문에 for문 돌기 전에 끝나서 0으로 나옴.

💡 join()에 무한대기(인자에 아무것도 안 씀) 걸거나 시간을 지정할 수도 있음. 예) join(200), join() …

🐶 join() 사용 후

public class Main {
    public static void main(String[] args) {
       SumTh sumTh = new SumTh();
       sumTh.start();
       try {
           sumTh.join(); // sumTh가 종료 될 때 까지 main이 대기 하고 있음
       } catch (InterruptedException e) {}
       System.out.println("합 : " + sumTh.getSum());
    }
}

class SumTh extends Thread {
    private long sum;

    public long getSum() {
        return sum;
    }

    public void setSum(long sum) {
        this.sum = sum;
    }

    @Override
    public void run() {
        for(int i = 0; i < 100; i++) {
            sum += 1;
            try {
                sleep(1);
            } catch (InterruptedException e) {}
        }
    }
}

합 : 100

스레드 간 협업 (wait(), notify(), nofifyAll())

경우에 따라 두 개의 스레드가 번갈아가며 실행해야 할 경우가 있습니다.
한 스레드가 작업을 완료하면 notify() 메소드를 호출해서 일시 정지 상태에 있는 다른 스레드를 실행 대기 상태로 만들고, 자신은 두번째 작업을 하지 않도록 wait() 메소드를 호출 합니다.
notifyAll() 메소드는 wait()에 의해 일시 정지된 모든 스레드를 실행 대기 상태로 만듭니다.

Main

public class Main {
    public static void main(String[] args) {
        WorkObject sharedObject = new WorkObject();
        ThreadA thA = new ThreadA(sharedObject);
        ThreadB thB = new ThreadB(sharedObject);
        thA.start();
        thB.start();
    }
}

WorkObject

public class WorkObject {
    public synchronized void methodA() {
        System.out.println("Thread의 methodA() 작업 실행");
        notify(); // 일시정지 상태인 ThreadB를 실행 대기 상태로 전환
        try {
            wait(); // ThreadA를 일시 정지 상태로 만듬
        } catch(InterruptedException e) {}

    }
    public synchronized void methodB() {
        System.out.println("Thread의 methodB() 작업 실행");
        notify(); // 일시정지 상태인 ThreadA를 실행 대기 상태로 전환
        try {
            wait(); // ThreadB를 일시 정지 상태로 만듬
        } catch(InterruptedException e) {}
    }
}

스레드에서 공통으로 사용하는 클래스 생성
synchronized : 멀티스레드 환경에서 동시 접속이 허용이 되지 않도록 lock을 거는 작업

ThreadA

public class ThreadA extends Thread {
    private WorkObject workObject;

    public ThreadA(WorkObject workObject) {
        this.workObject = workObject;
    }
    @Override
    public void run() {
        for(int i = 0; i < 10; i++) {
            workObject.methodA();
        }
    }
}

ThreadB

public class ThreadB extends Thread {
    private WorkObject workObject;

    public ThreadB(WorkObject workObject) {
        this.workObject = workObject;
    }

    @Override
    public void run() {
        for(int i = 0; i < 10; i++) {
            workObject.methodB();
        }
    }
}

스레드의 안전한 종료 (stop 플래그, interrupt())

스레드의 안전한 종료 방법은 stop 플래그를 구현하는 방법과 interrupt() 메소드를 사용하는 방법이 있다.

🐶 stop 플래그를 이용하는 방법

Main

public class Main {
    public static void main(String[]args) throws InterruptedException {
        RunThread runThread = new RunThread();
        runThread.start();
        Thread.sleep(1000);
        runThread.setStop(true);
    }
}

RunThread

public class RunThread extends Thread {
    private boolean stop; // stop 플래그 설정

    public void setStop(boolean stop) {
        this.stop = stop;
    }

    public void run() {
        while(!stop) {
            System.out.println("Thread 실행 중...");
        }
        System.out.println("자원 정리");
        System.out.println("실행 종료");
    }
}

🐶 interrupt() 메소드를 이용하는 방법

interrupt() 메소드는 스레드가 일시 정지 상태에 있을 때 InterruptException 예외를 발생시킨다.
이것을 이용하여 run() 메소드를 정상 종료 시킬 수 있다.

public class Main {
    public static void main(String[]args) {
        InterruptThread interThread = new InterruptThread();
        interThread.start();
        try {
            Thread.sleep(1000);
        } catch(InterruptedException e) { }
        interThread.interrupt();
    }
}

public class InterruptThread extends Thread {
    @Override
    public void run() {
        try {
            while (true) {
                System.out.println("스레드 실행 중.....");
                sleep(1); // interrupt 걸릴 수 있는 타이밍 (while(true) 탈출 조건)
            }
        } catch(InterruptedException e) {
            System.out.println("인터럽트 발생......");
        }
        System.out.println("종료를 위해 자원 정리 중.....");
        System.out.println("실행 종료");
    }
}

동기화 (synchronized)

멀티 스레드에서 특정 메소드나 블록{}에 대해 lock(잠금)을 설정하는 것
동시 접근으로 인해 발생할 수 있는 문제를 해결하기 위해 사용되며, 사용시 급격한 성능 저하가 발생할 수 있음
➡️ 적재 적소에 잘 사용해야 함

🐶 synchronized 하기 전..

import static java.lang.Thread.sleep;

public class Main {
    public static void main(String[] args) {
        SharedValue sharedValue = new SharedValue();
        // Runnable 인터페이스 익명의 스레드 생성
        Runnable th1 = new Runnable() {
            @Override
            public void run() {
                sharedValue.setValue(100);
            }
        };
        Thread thread1 = new Thread(th1);
        thread1.setName("스레드 1"); // 스레드 이름을 설정
        thread1.start();

        // Runnable 인터페이스 람다식으로 익명의 스레드 생성
        Runnable th2 = () -> {
          sharedValue.setValue(200);
        };
        Thread thread2 = new Thread(th2);
        thread2.setName("스레드 2");
        thread2.start();
    }
}

class SharedValue {
    private int value = 0;

    public int getValue() {
        return value;
    }
    public void setValue(int value) {
        this.value = value;
        try {
            sleep(2000);
        } catch(InterruptedException e) {
        }
        System.out.println(Thread.currentThread().getName() + "의 값 : " + getValue());
    }
}

스레드 1의 값 : 200
스레드 2의 값 : 200

synchronized 안하면 값이 깨짐.
public void setValue(int value) {}

🐶 synchronized 적용 후

import static java.lang.Thread.sleep;

public class Main {
    public static void main(String[] args) {
        SharedValue sharedValue = new SharedValue();
        // Runnable 인터페이스 익명의 스레드 생성
        Runnable th1 = new Runnable() {
            @Override
            public void run() {
                sharedValue.setValue(100);
            }
        };
        Thread thread1 = new Thread(th1);
        thread1.setName("스레드 1"); // 스레드 이름을 설정
        thread1.start();

        // Runnable 인터페이스 람다식으로 익명의 스레드 생성
        Runnable th2 = () -> {
          sharedValue.setValue(200);
        };
        Thread thread2 = new Thread(th2);
        thread2.setName("스레드 2");
        thread2.start();
    }
}

class SharedValue {
    private int value = 0;

    public int getValue() {
        return value;
    }
    public synchronized void setValue(int value) { // synchronized 안하면 값이 깨짐.
        this.value = value;
        try {
            sleep(2000);
        } catch(InterruptedException e) {
        }
        System.out.println(Thread.currentThread().getName() + "의 값 : " + getValue());
    }
}

스레드 1의 값 : 100
스레드 2의 값 : 200

💡 Thread 이름 생성

기본 스레드는 thread.getName()을 통해 Thread-n이라는 이름을 가집니다.

하지만 조금 더 수월한 디버깅을 위해 thread.setName("스레드 이름")을 통해 직접 설정할 수 있습니다.

subThread1.setName("테스트 쓰레드");
subThread1.start();

⭐데몬 스레드(daemon thread)

다른 스레드의 작업을 돕는 보조 스레드
다른 스레드가 모두 종료되면 데몬 스레드도 강제 종료 됨
start() 메소드 호출 전에 setDaemon(true)를 호출해야 함❗

public class Main {
    public static void main(String[] args) throws InterruptedException {
        AutoSaveThread auto = new AutoSaveThread();
        auto.setDaemon(true); // 데몬스레드 설정
        auto.start();
        sleep(30000);
    }
}

class AutoSaveThread extends Thread {
     public void save() {
         System.out.println("작업 내용을 저장함");
     }
     @Override
     public void run() {
         while(true) {
             try {
                 sleep(3000);
             } catch (InterruptedException e) {
             }
             save();
         }
     }
}

저작자표시 비영리 변경금지 (새창열림)