[Sec3] 쓰레드 생성과 실행

[CodingWon]

1.자바 메모리 구조

• 메서드 영역 : 프로그램을 실행하는데 필요한 공통 데이터를 관리

  1) 클래스 정보 : 클래스의 실행 코드(바이트 코드), 필드, 메서드와 생성자 코드등 모든 실행 코드가 존재

  2. static 영역 : static 변수들을 보관한다.

  3. 런타임 상수 풀 : 프로그램을 실행하는데 필요한 공통 리터럴 상수를 보관한다

• 스택 영역 : 자바 실행 시 하나의 스택이 생성

  • 스택 프레임 : 메서드를 호출할 때 마다 하나의 스택 프레임이 쌓이고, 메서드가 종료되면 제거된다.

• 힙 영역 : 객체(인스턴스) 와 배열이 생성되는 영역

2. 스레드 생성 - Thread 상속

• Thread 상속
  • 쓰레드 실행할 코드를 run 으로 재정의

public class HelloThread extends Thread {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + ": run()");
    }
}

• main 에서 호출
  • run() 메서드가 아니라 반드시 start() 메서드를 호출

public class HelloThreadMain {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName() + ": main() start");

        HelloThread helloThread = new HelloThread();
        System.out.println(Thread.currentThread().getName() + ": start() 호출전");

        helloThread.start();

        System.out.println(Thread.currentThread().getName() + ": start() 호출후");
        System.out.println(Thread.currentThread().getName() + ": main() end");
    }
}

• 실행 후 메모리 구조
  • 스레드 객체를 생성하고 start()를 호출해야 스택 공간을 할당 받고 스레드가 작동한다.
  • main 쓰레드는 다른 쓰레드에게 일을 하라고 지시만 하고 start() 메서드를 빠져 나온다.

스레드 간 실행 순서는 보장하지 않는다.

• 스레드는 순서와 실행 기간을 모두 보장하지 않는다. 이것이 바로 멀티스레드다.

3. 데몬 쓰레드

• 데몬 쓰레드

  • 백그라운드에서 보조적인 작업을 수행
  • 모든 user 쓰레드가 종료되면 데몬 쓰레드는 자동으로 종료된다.

• 데몬 쓰레드 생성

  • setDaemon(true) 로 설정 할 수 있다.

  public class DaemonThreadMain {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName() + ": main() start");
  
        DaemonThread daemonThread = new DaemonThread();
        daemonThread.setDaemon(true); // 데몬 스레드 여부
        daemonThread.start();
  
        System.out.println(Thread.currentThread().getName() + ": main() end");
    }
  
    static class DaemonThread extends Thread {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + ": run() start");
            try {
                Thread.sleep(10000); // 10초간 실행
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(Thread.currentThread().getName() + ": run() end");
        }
  
    }
  }

4. 스레드 생성 - Runnable

• Runnable 인터페이스

  package java.lang;
  
  public interface Runnable {
    void run();
  }

• 구현 클래스 - HelloRunnable

  public class HelloRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + ": run()");
    }
  }

• 실행

  • HelloRunnable 객체 생성
  • Thread 객체 생성시 HelloRunnable를 매개변수로 전달

  public class HelloRunnableMain {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName() + ": main() start");
        HelloRunnable runnable = new HelloRunnable();
        Thread thread = new Thread(runnable);
        thread.start();
        System.out.println(Thread.currentThread().getName() + ": main() end");
    }
  }

5. Thread 상속 vs Runnable 구현

1) Thread 상속 방식

• 장점
  • 간단한 구현 : Thread 클래스를 상속받아 run() 메서드만 재정의하면 된다
• 단점
  • 상속의 제한 : 자바는 단일 상속만 허용해서 다른 클래스를 상속 받는 경우 Thread 클래스 상속을 받을 수 없다.
  • 유연성 부족 : 인터페이스를 사용하는 방법에 비해 유연성이 떨어진다.

2) Runnable 인터페이스 구현 방식

• 장점
  • 상속의 자유로움
  • 코드의 분리
  • 여러 스레드가 동일한 Runnable 객체를 공유할 수 있어 자원 관리를 효율적으로 할 수 있다.
• 단점
  • 코드가 살짝 복잡 해짐... Runnalbe 객체를 만들고 Thread 에 전달해야 한다.

결론 - Runnable 를 사용해라 !

6. 로거 만들기

• MyLogger

  import java.time.LocalTime;
  import java.time.format.DateTimeFormatter;
  
  public abstract class MyLogger {
    private static final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH:mm:ss.SSS");
  
    public static void log(Object obj) {
        String time = LocalTime.now().format(formatter);
        System.out.printf("%s [%9s] %s\n", time, Thread.currentThread().getName(), obj);
    }
  }

• main

  import static util.MyLogger.log;
  
  public class MyLoggerMain {
    public static void main(String[] args) {
        log("hello thread");
        log(123);
    }
  }

• 결과

  15:39:02.000 [ main] hello thread
  15:39:02.002 [ main] 123

7. 여러 쓰레드 만들기

• 쓰레드 3개 생성

  package thread.start;
  
  import static util.MyLogger.*;
  
  public class ManyThreadMainV1 {
    public static void main(String[] args) {
        log("main() start");
  
        HelloRunnable runnable = new HelloRunnable();
  
        Thread thread1 = new Thread(runnable);
        thread1.start();
  
        Thread thread2 = new Thread(runnable);
        thread2.start();
  
        Thread thread3 = new Thread(runnable);
        thread3.start();
  
        log("main() end");
    }
  }

• 실행 결과

  • 스레드의 실행 순서는 보장되지 않는다.

  15:52:34.602 [ main] main() start
  15:52:34.604 [ main] main() end
  Thread-2: run()
  Thread-1: run()
  Thread-0: run()

• 스택 프레임

8. Runnable을 만드는 다양한 방법

1) 정적 중첩 클래스 사용

package thread.start;

import static util.MyLogger.log;

public class InnerRunnableMainV1 {
    public static void main(String[] args) {
        log("main() start");
        Runnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);
        thread.start();
        log("main() end");
    }

    static class MyRunnable implements Runnable {
        @Override
        public void run() {
            log("run()");
        }
    }
}

2) 익명 클래스 사용

package thread.start;

import static util.MyLogger.log;

public class InnerRunnableMainV2 {
    public static void main(String[] args) {
        log("main() start");

        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                log("run()");
            }
        };

        Thread thread = new Thread(runnable);
        thread.start();

        log("main() end");
    }
}

3) 익명 클래스 변수 없이 직접 전달

package thread.start;

import static util.MyLogger.log;

public class InnerRunnableMainV3 {
    public static void main(String[] args) {
        log("main() start");
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                log("run()");
            }
        });
        thread.start();
        log("main() end");
    }
}

4) 람다

package thread.start;

import static util.MyLogger.log;

public class InnerRunnableMainV4 {
    public static void main(String[] args) {
        log("main() start");// 람다를 배우면 이해
        Thread thread = new Thread(() -> log("run()"));
        thread.start();
        log("main() end");
    }
}

9. 문제 4 : 여러 쓰레드 사용

• Thread-A , Thread-B 두 스레드를 만들어라
• Thread-A 는 1초에 한 번씩 "A"를 출력한다.
• Thread-B 는 0.5초에 한 번씩 "B"를 출력한다.
• 이 프로그램은 강제 종료할 때 까지 계속 실행된다.

public class StartTest4Main {
    public static void main(String[] args) {
        Thread threadA = new Thread(new PrintWork("A", 1000), "Thread-A");
        Thread threadB = new Thread(new PrintWork("B", 500), "Thread-B");
        threadA.start();
        threadB.start();
    }

    static class PrintWork implements Runnable {
        private String content;
        private int sleepMs;

        public PrintWork(String content, int sleepMs) {
            this.content = content;
            this.sleepMs = sleepMs;
        }

        @Override
        public void run() {
            while (true) { // 무한 루프
                log(content);
                try {
                    Thread.sleep(sleepMs);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

[JisuPark-dev]

Runnable만드는 다양한 방법에 대해서 말씀해주셨는데, 보통은 runnable 패키지를 따로 파서 거기에다가 도메인별로 필요한 작업을 모아서 관리하지 않을까요?

[JisuPark-dev]

오호 실제로 그렇게 한다네요. com.example.project ├── runnable │ ├── email │ │ ├── EmailSenderRunnable.java │ │ ├── EmailLoggerRunnable.java │ ├── file │ │ ├── FileUploaderRunnable.java │ │ ├── FileProcessorRunnable.java │ ├── notification │ │ ├── NotificationSenderRunnable.java │ │ ├── NotificationCleanerRunnable.java