Home 12. Thread
Post
Cancel

12. Thread

Posted Apr 22, 2022
By ABarthDew
80 min read

목차

12.1 멀티 스레드 개념
12.2 작업 스레드 생성과 실행
- 12.2-1. Thread 클래스로부터 직접 생성하는 방법
- 12.2-1. 정리
- 12.2-2. Thread 하위 클래스로부터 생성하는 방법
- 12.2-2. 실습
- 12.2-2. 정리
- 결론
12.3 스레드 우선 순위
12.4 동기화 메소드와 동기화 블록
- 여러 스레드가 공유하는 객체가 항상 변할 수 있다는 문제점을 해결할 방법
12.5 스레드 상태
- 실습 - 12.5. thread
- 실습 - 12.5. thread (detail)
12.6 스레드 상태 제어(1)
12.6 스레드 상태 제어(2)
12.7 데몬 스레드
12.8 스레드 그룹
- 실습 - 12.7.group2
12.9 스레드풀(1)
- ExecutorService, 즉, 스레드 풀의 동작 원리
12.9 스레드풀(2)
- 실습 - 12.9.ExecuteSubmit4Exam.java
- 실습 - 12.9.blocking
12.9 스레드풀(3)
- 실습 - 12.9.result
12.9 스레드풀(4)
- 실습 - 12.9.CompletionService
참고자료

12.1 멀티 스레드 개념

Untitled

  • 프로그램을 실행할 때, 운영체제는 프로세스를 하나 만들어, CPU와 메모리를 사용할 수 있도록 함
  • 프로그램 당 여러 개의 프로세스가 실행될 수 있음
  • 각 프로세스들은 독립적으로 운영체제에서 실행되며, CPU와 메모리를 사용함

Untitled

  • 예) 크롬 실행 → 1개의 프로세스 생성, 크롬 하나 더 실행 → 프로세스 하나 더 생성됨
  • 작업 관리자 창의 응용 프로그램 각 하나 하나가 프로세스임
  • 하나의 프로그램이라도 몇 번 실행했는가에 따라 여러 개의 프로세스가 만들어 질 수 있음

Untitled

  • main() 메서드는 JVM에서 생성되는 main 스레드가 생성함
  • 즉, main() 메서드를 실행하는 스레드가 main 스레드
  • 스레드는 하나의 코드 실행 흐름이라고 할 수 있음
  • main 스레드는 main() 메서드를 첫 코드 부터 아래로 순차적으로 실행함

Untitled

  • JVM이 main 스레드를 만들고, main 스레드가 작업 스레드(또 다른 스레드)를 만듬
  • 싱글 스레드: main 스레드 하나만 있는 스레드
  • 멀티 스레드: main 스레드가 실행되며 main 스레드가 다른 스레드를 만들어 실행하는 스레드 환경
  • 멀티 스레드 애플리케이션

    • 프로세스 생성 → JVM이 main 스레드 생성 → main() 메서드 실행

      → main() 메서드 실행 중 어떤 시점에 새로운 작업 스레드 생성

      → 작업 스레드 코드 실행

      → main 스레드가 먼저 종료될 시, 애플리케이션은 종료하지 않고, 나머지 스레드가 모두 종료되어야 프로세스는 종료됨

12.2 작업 스레드 생성과 실행

Untitled

12.2-1. Thread 클래스로부터 직접 생성하는 방법

Untitled

  • 동시에 실행을 할 수 있다는 의미에서, Runnable 인터페이스를 구현
  • Runnable 인터페이스는 작업 스레드가 실행할 수 있는 클래스를 만들겠다는 뜻
  • Runnable의 run() 메서드를 정의한 후, main 스레드 실행 동안 동시에 실행할 또 다른 스레드의 코드를 run()에 넣음
  • 여기까지 진행 후, 스레드로부터 run() 메서드를 실행할 수 있게 만들어 줘야 함

    1. Runnable 구현 객체를 생성

      1
2
3

       Runnable task = new Task();
 Thread thread = new Thread(task); // Thread 객체가 task 실행하게 됨 => 결국 task 안의 run() 실행
 // Thread 객체: 자바에서는 하나의 스레드도 객체화 해서 사용함

    2. 익명 객체 생성(1과 같음, 표현만 다름)

      1
2
3
4
5

       Thread thread = new Thread(new Runnable() {
   public void run() {
     // 스레드가 실행할 코드
   }
 });

    3. 자바 8부터 추가된 람다식 사용

      1
2
3

       Thread thread = new Thread(() -> {
   // 스레드가 실행할 코드
 });

      • 람다식으로 작성 가능한 이유: Runnable 인터페이스가 run() 이라는 메서드 단 하나만 가지고 있기 때문

        → Runnable은 함수적 인터페이스에 해당됨

      • Runnable에 매개값이 없기 때문에 () → {} 와 같이 ()로 표현 가능
      • () → {} 의 {}는 아래 코드의 {}과 동일함
      1
2
3

       public void run() {
   // 스레드가 실행할 코드
 }
      • 람다식은 결국 Runnable 이라는 객체로 생성됨
  • 1, 2, 3은 모두 동일한 의미의 코드며, 표현만 다름

  • 새로운 스레드 생성 후, thread.start()로 새로운 메서드를 호출 시켜주면, 비로소 스레드가 실행됨

    ⇒ 이 때, 스레드가 실행하는 코드는 run() 메서드 안에 있는 코드

12.2-1. 정리

  • 동시에 실행해야 할 작업들이 있다

    → 해당 작업에 대한 클래스들을 생성하고 Runnable 인터페이스 구현체로 만듬

    → run() 메서드 재정의 후, 스레드가 실행할 코드를 넣어 줌

    → (여기까지, 이 작업 자체가 스레드인 건 아니고, 그냥 동시 실행해야 할 작업들을 클래스에 정의한 것)

    → Thread 객체 생성 후, 매개값으로 작업 객체를 넣어 주면,

    → 해당 스레드 객체가 start() 메서드 호출 시 작업 객체의 run()을 실행하게 됨

12.2-2. Thread 하위 클래스로부터 생성하는 방법

Untitled

  • 이전에 Thread 클래스로부터 직접 생성하는 방법에선 Runnable 객체가 필요했지만, Thread를 직접 상속받으면 하위 클래스로부터 Thread 객체를 직접 만들 수 있음
    1. 명시적으로 하위 클래스를 만들어 Thread 객체를 생성하는 방법
    1
2
3
4
5
6
7

      Public class WorkerThread extends Thread { // Thread 상속
    @Override
    public void run() {
      // 스레드가 실행할 코드
    }
  }
  Thread thread = new WorkerThread(); // 하위 클래스로부터 Thread 객체 직접 만들기

  1. 익명 객체를 만들어 Thread를 생성하는 방법

    1
2
3
4
5
6

     				// new Thread()로 생성자 호출
 Thread thread = new Thread() { // {}: Thread를 상속하는 하위 객체를 익명 객체로 만듬
   public void run() { // run() 메서드 재정의, 새로운 작업 스레드가 실행할 코드 작성
     // 스레드가 실행할 코드
   }
 };
  • 실행: thread.start();

Untitled

  • 스레드는 개별적으로 별도의 이름을 가질 수 있음
  • main 스레드도 main 이라는 이름을 가지고 있는 것(JVM이 main 스레드를 생성할 때 이름을 부여)
  • 작업 스레드를 생성하게 되면, 기본적으로 Thread-1, 2, 3, … 라는 이름이 부여됨

12.2-2. 실습

1
2
3

Thread thread2  = new ThreadA();
System.out.println(Thread.currentThread().getName()); // main
thread2.start();

  • Thread.currentThread().getName(): 해당 스레드를 생성한 스레드(ThreadA를 생성한 스레드)

    ⇒ 즉, 현재 이 코드를 실행하는 스레드를 얻어, 이름을 가져온다

  • 아래 두 코드는 main 에서 실행되지만,

    1
2

      Thread thread2  = new ThreadA();
  thread2.start();

    ⇒ thread.start()를 하는 순간, ThreadA의 run() 메서드가 실행됨

12.2-2. 정리

  • Thread를 생성함과 동시에, start() 메서드를 호출할 수 있음

  • Thread threadA = new ThreadA(); 와 같이 스레드 생성 후, start() 메서드 호출 후, run() 메서드가 실행되고 나면, 다시 start()를 재호출 할 수 없음

    ⇒ start()는 딱 한 번만 호출 가능

  • 만약, 새로운 스레드가 필요한데 이전 스레드와 작업 내용이 같다면, 그 때 start()를 재호출 할 수는 없음

    ⇒ 아래 예시와 같이 threadA를 다시 호출한 후 start()를 사용해야 함

    1
2
3
4
5

      Thread threadA = new ThreadA();
  threadA.start(); // 재사용 불가
    
  threadA = new ThreadA();
  threadA.start(); // 재사용 불가

결론

  • 해당 코드 자체는 main 스레드에 의해 실행됨
1

System.out.println("작업 스레드 이름(ThreadA의 이름): " + thread2.getName()); // main 스레드가 threadA의 이름을 얻기 위해 getName() 메서드 호출
  • 항상 해당 작업을 어떤 스레드가 실행시키는가를 알아야 함

Untitled

  • 위 코드는 모두 main 스레드가 실행하는 것
  • 하지만, threadA와 threadB가 실제로 실행하는 코드는 각각의 객체에 재정의된 run() 메서드 안의 코드임

12.3 스레드 우선 순위

Untitled

  • 스레드 우선 순위: 여러 가지 스레드가 있을 때, 어떤 스레드가 실행 우선 순위를 가지느냐
  • 동시성: CPU의 코어 중 하나에서, 2개 이상의 스레드가 실행되는 현상
    • 하나의 코어는 한 시점에 하나의 스레드만 실행 가능
    • 때문에, 하나의 코어에서 멀티 스레드를 실행하려면, 한 시점에 스레드1을 조금 실행 시키고, 한 시점에 스레드 2를 조금 실행시키고, 스레드를 번갈아서 실행시키는 형태로 진행함
    • 코어 하나에 스레드 여러 개기 때문에, 코어가 어떤 스레드를 실행하는 도중엔 다른 스레드는 대기 상태가 됨
  • 병렬성: 각각의 코어에서 스레드 하나씩 실행
    • 스레드1이 실행될 동안 스레드 2도 실행됨
    • 각각의 스레드는 실행에 방해를 받지 않고 계속 코드를 실행해 나갈 수 있음
    • 처리 속도가 보다 빠름

Untitled

  • 각 스레드는 대기 상태로 있다가, 스케줄링에 의해 하나의 스레드가 선택되면 실행하게 됨

    → 이 스레드가 실행해야 할 run() 메서드를 모두 실행하는 것이 아니라, 조금씩 실행함

    → 스레드 1이 실행된다고 하면, run()이 다 실행되지 않은 시점에서 다시 대기 상태가 되고,

    → 뒤이어 스레드 2가 실행되어 run()을 실행하다가 다시 대기 상태가 됨

    → 뒤이어 스레드3이 실행되어 run()을 실행하다가 다시 대기 상태가 됨

    → 이렇게 반복적으로 계속 실행

    → 스레드 1이 run() 메서드를 다 실행하게 되면, 스레드 1 종료, 대기 상태에서 빠지게 됨

  • 자바에서는 스레드 스케줄링으로 우선 순위 방식과 순환할당(라운드 로빈) 방식을 이용함
    • 우선순위: 우선순위가 높은 스레드가 좀 더 많은 실행 기회를 가짐
    • 순환 할당: 정해진 시간 할당량 만큼 각각의 스레드를 실행함
  • 자바에서는 기본적으로 순환 할당 방식을 사용하며, 부가적으로 스레드에 우선순위를 주어 우선 순위 방식을 사용할 수도 있음

Untitled

  • 쿼드 코어에, 4개 이하의 스레드를 실행할 경우, 우선 순위 방식은 크게 영향을 미치지 못함

    → 코어가 4개, 스레드가 4개 이하이므로, 코어 당 스레드가 하나씩 독립적으로 실행되기 때문에 우선 순위를 매기는 의미가 없음

12.4 동기화 메소드와 동기화 블록

Untitled

  • user1 스레드와 user2 스레드가 똑같이 Calculator 객체를 사용한다고 가정한다

  • 위 예에서, user1 스레드의 memory 값은 100이 아닌 50으로 출력됨

    ⇒ 공유 객체를 사용할 때, 다른 스레드가 값을 변경하게 되면 또 다른 스레드에 영향을 미침

여러 스레드가 공유하는 객체가 항상 변할 수 있다는 문제점을 해결할 방법

Untitled

  • 하나의 스레드가 동기화 메서드 또는 동기화 블록을 사용할 때, 다른 스레드는 이 메서드를 사용할 수 없음
  • 이 예시에서는 user1이 완전히 끝날 때까지 다른 스레드가 동기화 블록 안에 있는 Calculator 필드 값을 바꿀 수 없음
  • 즉, 동기화 메서드 또는 동기화 블록은 한 번에 하나의 스레드만 사용 가능

  • 만약, 스레드1, 스레드2가 동시에 실행이 된다고 가정할 때

    ⇒ 스레드1 이 먼저 동기화 블록을 사용하게 됐다면, 스레드2는 스레드1이 동기화 블록 사용을 종료할 때까지 대기 상태가 됨

    ⇒ 스레드1이 동기화 블록 사용을 종료하면 그제야 스레드2도 동기화 블록 사용 가능

  • 잠금: user1이 동기화 블록 내 Calculator 객체를 사용할 때, 다른 스레드가 이 객체를 사용할 수 없도록 잠궈버림

    ⇒ 다른 동기화 메서드도 전부 사용 안 됨

    ⇒ 만약, Calculator 객체 안에 동기화 메서드가 5개가 있다고 가정하면, user1의 스레드가 그 중 하나를 사용하고 있을 때, user2는 나머지 4개의 동기화 메서드에도 접근하지 못함

    ⇒ Calculator 객체 자체가 잠겨있기 때문에

  • synchronized(공유 객체) {}: 공유 객체에는 ‘잠금 객체’가 매개값으로 들어 감

Untitled

  • 위 예제와 같이, user1 스레드가 m1(), m2(), m3() 셋 중 하나만 사용 중이라도 user2 스레드는 m1(), m2(), m3() 중 아무것도 사용하지 못함

    ⇒ Calculator 객체 자체가 잠금 되기 때문에

  • 만약, synchronized 가 붙어있지 않는 m4() 메서드가 있다면, user1이 실행되는 와중에도 user2는 m4() 메서드 사용 가능

12.5 스레드 상태

Untitled

  • 스레드 객체 생성: Thread는 new 연산자로 객체 생성 후 종료 시까지 여러 상태를 가질 수 있음
  • 실행 대기: start() 메서드를 호출하면 스레드는 실행 대기 상태가 됨
  • 실행: 실행 대기 상태에 있는 스레드는 CPU 스케줄로 인해 선택이 되면 실행되게 됨
  • 실행하다 실행 대기 상태가 되고, 또 실행하다 실행 대기 상태가 되는 것을 반복하다가, run() 메서드를 종료하게 되면 종료 상태가 됨

  • 실행 상태에서 실행 대기로 가지 않고, 일시 정지로 가는 경우도 있음

    ⇒ 일시 정지 상태: waiting, time_waiting, blocked

  • 일시 정지 상태에 있는 스레드는 다시 실행 대기 상태로 감 → 여기서 CPU 스케줄로 선택 받아서 실행하게 됨
  • [표]: 스레드 상태에 대한 열거 상수들
    • blocked
      • 스레드 a가 동기화 블록을 사용하고 있을 때, 스레드 b는 해당 동기화 블록에 접근할 수 없으므로 blocked 상태가 됨
      • 스레드 a가 동기화 블록 사용을 완료하면 스레드 b는 blocked 상태가 해제되어 실행 대기 상태가 됨 → 실행
    • waiting
      • Object가 가지고 있는 wait() 메서드가 있는데, 이를 호출하게 되면 스레드 c는 일시정지 상태로 감
      • waiting된 스레드 c는 다른 스레드 d가 notify() 메서드를 호출해야 비로소 실행 대기 상태로 갈 수 있음
      • 즉, waiting된 스레드는 자기 스스로 실행 대기 상태로 갈 수 없고, 다른 스레드가 알려줘야 실행 대기 상태로 갈 수 있음
    • timed_waiting
      • sleep() 메서드에 시간을 주게 되면, 그 시간동안 스레드는 일시 정지 상태가 됨
      • 주어진 시간이 지나면 자동으로 실행 대기 상태로 감
    • terminated
      • 스레드는 한번 생성되고 종료되면 재사용이 불가능
      • 스레드를 다시 사용 하고 싶다면 새로 생성 후 start() 해서 실행 대기 상태로 만들어 주어야 함

실습 - 12.5. thread

Untitled

Untitled

  • java.lang → Thread → class Thread 의 중첩 클래스인 NESTED 클릭

    ⇒ Thread.State라는 열거 타입이 있는 것을 확인할 수 있음

Untitled

Untitled

  • Enum으로 선언되어 있음을 확인할 수 있음

Untitled

  • 위와 같은 열거 상수가 정의되어 있음을 확인할 수 있음

실습 - 12.5. thread (detail)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

public class StatePrintThread extends Thread {
  // 1. StatePrintThread는 targetThread의 상태를 계속해서 출력하는 스레드
  
  private Thread targetThread;
  
  // 2. 생성 시 targetThread의 객체를 받아 필드에 저장
  public StatePrintThread (Thread targetThread) { 
    this.targetThread = targetThread;
  }
  
  @Override
  public void run() {
    while (true) {
      // 3. StatePrintThread 실행 시, targetThread의 상태를 얻어냄
      Thread.State state = targetThread.getState();
      // 4. 얻어 낸 targetThread의 상태를 출력
      System.out.println("타겟 스레드 상태: " + state);
      // 5. targetThread 상태가 NEW가 되면(처음 만들어졌으면) 이 스레드를 start() 시킴 -> targetThread의 run() 메서드 실행
      if (state == Thread.State.NEW) { 
        targetThread.start();
      }
      // 6. statePrintThread는 0.5초 주기로 반복문을 돌며 계속 targetThread의 상태를 출력함
      // 7. 그러다 targetThread가 종료되면, while 문을 빠져나옴
      if (state == Thread.State.TERMINATED) { 
        break;
      }
      try {
        Thread.sleep(500);
      } catch (InterruptedException e) {} 
    }
  }
}

  • 타겟 스레드 상태: NEW

    Untitled

    • new TargetThread 객체를 생성한 상태

  • 타겟 스레드 상태: RUNNABLE

    Untitled

    • targetThread.start()가 호출되면 실행 대기 상태가 됨

    • 실행 대기 상태에서 CPU 스케줄로 선택되면 실행 상태가 됨

      ⇒ 실행 대기, 실행 상태 모두 포함 의미

    Untitled

    • RUNNABLE 상태는 targetThread가 for문을 실행할 단계의 상태임
  • 타겟 스레드 상태: RUNNABLE
    • 실행 대기, 실행 상태를 오가며 상태가 변경되고 있음
  • 타겟 스레드 상태: RUNNABLE
    • 실행 대기, 실행 상태를 오가며 상태가 변경되고 있음

  • 타겟 스레드 상태: TIMED_WAITING

    Untitled

    • 1.5초 동안 일시정지 되었을 때
  • 타겟 스레드 상태: TIMED_WAITING
  • 타겟 스레드 상태: TIMED_WAITING

  • 타겟 스레드 상태: RUNNABLE

    Untitled

    • 1.5초 뒤, 다시 targetThread가 for 문을 반복하며 RUNNABLE 상태가 됨
    • CPU의 선택을 받아 실행, 대기 상태를 왔다 갔다 하며 실행과 대기를 반복함
  • 타겟 스레드 상태: RUNNABLE

  • 타겟 스레드 상태: TERMINATED

    Untitled

    • run() 종료, targetThread는 TERMINATED 상태가 됨

  • targetThread가 종료되면 statePrintThread도 break로 반복문을 빠져나감 → 종료

    Untitled

12.6 스레드 상태 제어(1)

  • 스레드 상태를 변화시키기 위해서는 메서드를 사용해야 함

Untitled

  • 처음 스레드를 생성하게 되면, 실행 대기 상태가 됨

    → CPU 스케줄러에 의해 선택되면, 실행 상태가 됨

    → 실행 상태에서 시간 할당량이 다 되면 다시 실행 대기 상태가 됨

  • yield() 호출: 실행 중, 시간 할당량이 되기 전에, 실행 대기 상태로 만듦
  • sleep() 호출:
    • 실행 중, timed_watiting이 되어, 주어진 시간 동안 일시 정지 상태로 만듦
    • 주어진 시간이 지나면 다시 실행 대기 상태가 됨
  • join() 호출:
    • 실행 중, 일시 정지 상태로 만듦
    • join() 메서드를 호출한 스레드가 종료되면 다시 실행 대기 상태가 됨
  • wait() 호출:
    • 실행 중, 일시 정지 상태가 됨
    • wait()로 일시 정지된 스레드는 자기 스스로 실행 대기 상태가 될 수 없음
    • 다른 스레드가 notify() 또는 notifyAll()을 실행해 줘야 일시 정지가 풀려 실행 대기 상태가 될 수 있음
  • interrupt() 호출:
    • 일시 정지 상태에서 호출되면 예외 발생, 예외 발생과 동시에 일시 정지 상태가 풀리며 실행 대기 상태로 갈 수 있음
  • resume(), suspend(): deplicated. 더 이상 사용하지 않음.
  • stop():
    • 실행 중 호출하면 바로 종료 상태가 됨, 그러나 사용하지 않음
    • 갑자기 실행 중 종료되면 프로그램 상태가 불안정해지기 때문에, 가급적 사용하지 않는 것을 권장

Untitled

  • 주어진 시간 동안 일시 정지 → 주어진 시간 후 실행 대기 상태
  • 일시 정지 도중에 interrupt() 메서드가 호출되면 예외가 발생할 수 있기 때문에, 예외 처리 필수

Untitled

  • 실행 대기 상태인 스레드1, 스레드2가 있는 경우

  • 스레드1이 실행 중일 때, yield() 메서드 호출 시 스레드1은 즉시 실행 대기 상태가 됨

    ⇒ 스레드1과 동일하거나 보다 높은 우선순위를 갖는 스레드2가 실행할 수 있도록 함

  • 즉, yield()는 현재 실행 상태인 스레드를 실행 대기 상태로 되돌리는 역할을 함
  • 보통 yield() 메서드는 무의미한 반복을 하지 않고, 다른 스레드에게 실행을 양보할 때 주로 사용됨

Untitled

  • 무의미한 반복 → work가 false가 될 경우, 다른 스레드에게 실행을 양보하는 코드

Untitled

  • join() 메서드 테스트를 위해서는 2개의 스레드가 필요

  • 스레드a에서 스레드b를 start() → 스레드b run()

    ⇒ 스레드a에서 스레드b.join() 호출 → 스레드b가 아닌, 스레드 a가 일시 정지 상태가 됨

  • 스레드b가 run() 메서드를 종료할 때까지 스레드a를 일시 정지 상태로 만듦

    ⇒ 스레드b가 run() 메서드를 종료하면, 스레드 a는 일시 정지 상태에서 풀려나 실행 대기 상태가 됨

    ⇒ 스레드a는 이후 순차적으로 코드를 실행해 나감

  • 보통 스레드a가 계산 작업 클래스인 스레드b의 계산 결과를 받아 작업하는 경우에 사용

Untitled

  • sleep(), yield(), join()이 스레드가 가지는 메서드인 것에 반해, wait(), notify(), notifyAll()은 스레드 메서드가 아님

    ⇒ Object가 가지는 메서드(모든 객체가 가지고 있는 메서드)

  • 일반 메서드는 wait(), notify(), notifyAll()를 호출할 수 없고, 동기화 메서드 또는 블록만 호출 가능함

    ⇒ (1), (2) 부분에만 사용 가능(공유 객체를 사용할 때 호출하는 메서드들이기 때문)

    1
2
3
4
5
6
7
8
9
10
11

      // 동기화 메서드
  synchronized void method () {
    // ...(1)
  }
    
  void method() {
    // 동기화 블럭(메서드 일부분)
    synchronized(this) {
      // ...(2)
    }
  }
  • wait():
    • 호출한 스레드는 일시 정지 상태가 되며, watiting pool에 스레드가 관리됨

    • 일시 정지 된 스레드는 자기 스스로 실행 대기 상태로 갈 수 없음

      ⇒ 실행 상태인 다른 스레드가 notify(), notifyAll()을 호출해 줘야 실행 대기 상태로 갈 수 있음

  • wait(long timeout, [int nanos]):
    • wait()와는 달리 매개 값으로 들어 온 시간이 지나면 자동으로 대기 상태가 됨
    • 매개 값인 timeout 시간이 지나기 전에, 다른 스레드가 notify(), notifyAll()을 호출해 주면, 그 즉시 실행 대기 상태로 감

12.6 스레드 상태 제어(2)

wait(), notify()를 이용해 공유 객체를 번갈아 사용하는 예제

  • 소비자 스레드가 데이터 소비, 생성자 스레드가 데이터 생성

Untitled

  • stop() 메서드는 스레드를 즉시 종료시키지만, 불안정한 종료가 되므로 권장하지 않음
  • 스레드의 종료: run() 메서드가 종료됨을 의미
  • 안전한 종료 방법:

    1. stop 플래그로 run() 메서드의 정상 종료를 유도

      ⇒ 일시 정지 상태의 스레드를 종료하지는 못함

    2. interrupt() 메서드 사용

      ⇒ 일시 정지 상태인 스레드도 종료 가능

      ⇒ interrupt() 호출 시, 일시 정지 상태인 스레드에서 InterruptedException 발생

Untitled

  • Thread.sleep(1); 와 같이 스레드가 일시 정지된 상태에서 threadB.interrupt(); 와 같이 interrupt() 메서드 호출 시 → 예외 발생

    ⇒ while 반복문에서 catch로 내려와 스레드의 run() 메서드가 종료됨

  • 실행 대기, 실행 상태에서는 InterruptExcaption이 발생하지 않음

    ⇒ 위 그림의 ThreadB에서 Thread.sleep(1); 코드가 없다면, threadB.interrupt(); 와 같이 interrupt() 메서드가 호출되더라도 예외가 발생하지 않음

  • 즉, interrupt() 메서드를 호출해도 일시 정지 코드가 있어야 예외가 발생하고, run() 메서드가 종료함

  • 일시 정지 상태로 만들지 않고 whild 문을 빠져나오는 방법: interrupted(), isInterrupted() 사용

    1
2
3

      // interrupt() 메서드가 호출되었으면 true, 아니면 false를 return
  boolean status = Thread.interrupted(); // Thread의 정적 메서드 사용
  boolean status = objThread.isInterrupted(); // Thread 객체를 생성한 후 인스턴스 메서드 사용

12.7 데몬 스레드

Untitled

  • thread.setDaemon(true): AutoSaveThread 스레드는 main 스레드의 데몬 스레드가 됨
  • 마지막 }에서 main 스레드가 종료되면 AutoSaveThread는 자동으로 종료됨

12.8 스레드 그룹

Untitled

Untitled

  • 스레드 그룹을 계층적으로 만들어 관리할 수 있음

  • 자동 생성되는 스레드 그룹도 있음

    ⇒ 자바 프로그램을 실행하게 되면, system 그룹과 system의 하위 그룹인 main 그룹이 자동으로 생성됨

  • 스레드는 기본적으로 자신을 생성한 스레드와 같은 그룹에 속하게 됨

    ⇒ main 그룹에 있는 main 스레드에서 스레드를 생성하게 되면, main 그룹에 자동으로 소속됨

    ⇒ sub 그룹에 소속된 sub 스레드가 스레드를 생성하게 되면, 자동적으로 sub 그룹에 소속됨

  • main 스레드가 소속된 그룹이 main 그룹이므로, main 스레드가 생성하는 또 다른 스레드는 모두 기본적으로 main 그룹에 속함

    ⇒ 명시적으로 스레드 그룹에 포함시키지 않으면 기본적으로 main 그룹에 속함

Untitled

1
2

ThreadGroup tg = new ThreadGroup(String name); // 현재 스레드가 속한 그룹의 하위 그룹으로 생성됨
ThreadGroup tg = new ThreadGroup(ThreadGroup parent, String name); // parent 그룹 밑의 하위 그룹으로 생성됨

Untitled

Untitled

실습 - 12.7.group2

Untitled

  • WorkThread가 스레드 그룹에 포함되기 위해서는

Untitled

  • Thread의 생성자를 호출해 주어야 함

Untitled

  • 스레드 그룹은 생성자 외부에서 받도록 하고, 스레드 이름을 두 번째 매개 값으로 받음

Untitled

  • run() 메서드 재정의: 무한 루프를 돌되, 1초 동안 쉬게 해 줌
  • 나중에 interrupt() 메서드가 호출될 시 예외가 발생하도록 하기 위함

Untitled

  • 이 코드를 실행하는 것은 main 메서드, 즉 main 스레드 이므로, 결국 main 스레드가 포함된 main 그룹에 myGroup이 하위 그룹으로 만들어짐

Untitled

  • main 그룹 밑에 main 스레드, main 그룹 밑에 myGroup

Untitled

  • 다음 단계: myGroup 밑에 workThreadA, workThreadB를 포함시킴

Untitled

  • 처음 JVM 이 실행되면,
    1. system이라는 스레드 그룹 생성
    2. system 밑에 main 그룹 생성
    3. main 그룹 밑에 main 스레드 포함
    4. main 그룹의 서브 그룹으로 myGroup 포함
    5. myGroup 밑에 workThreadA, workThreadB 포함

  • 출력 결과

    1
2
3
4
5
6

      // main 스레드 그룹의 list() 메서드 출력 내용
  java.lang.ThreadGroup[name=main,maxpri=10]
    Thread[main,5,main]
    java.lang.ThreadGroup[name=myGroup,maxpri=10]       
      Thread[workThreadA,5,myGroup]
      Thread[workThreadB,5,myGroup]
    • java.lang.ThreadGroup[name=main,maxpri=10]
      • 스레드 그룹의 이름이 main 이며, 이 스레드 그룹에 포함된 스레드가 가질 수 있는 최대 우선순위는 10번
    • Thread[main,5,main]
      • 이 스레드 그룹에 포함된 스레드 중 하나의 이름은 main 이고, 우선순위는 5며, 이 스레드가 포함된 스레드 그룹의 이름은 main임
    • java.lang.ThreadGroup[name=myGroup,maxpri=10]
      • main 그룹 내 서브 그룹으로 myGroup이 있으며, 이 그룹에 소속된 스레드가 가질 수 있는 최대 우선순위는 10번
    • Thread[workThreadA,5,myGroup]
      • myGroup에 포함된 스레드 workThreadA, 우선순위는 5번이며, 이 스레드가 포함된 그룹 이름은 myGroup
    • Thread[workThreadB,5,myGroup]
      • myGroup에 포함된 스레드 workThreadB, 우선순위는 5번이며, 이 스레드가 포함된 그룹 이름은 myGroup

12.9 스레드풀(1)

Untitled

  • 브라우저에서 웹 서버에 접근하게 되면, 웹 서버는 하나의 스레드를 만들어 처리함

  • 수천 개의 브라우저가 웹 서버에 접근하게 되면, 스레드도 수천 개 만들어져 동시에 실행됨

    Untitled

    ⇒ 스레드 폭증, CPU 과부하, 웹 서버 메모리도 많이 사용됨

    ⇒ 웹 서버에서 실행하는 서버 애플리케이션 성능이 급격히 저하됨

  • 스레드 풀: 아무리 많은 브라우저가 접근하더라도, 웹 서버 내 스레드 개수를 적절히 조절

    Untitled

    • 여러 작업 요청이 들어오면, 이 요청들을 큐 라는 공간에 저장해 놓고, 작업 당 스레드가 처리하도록 함
    • 즉, 제한된 스레드가 큐에 있는 작업을 하나씩 맡아 처리하는 방식
    • 작업을 다 처리한 스레드는 큐에서 다음 작업을 가져와 처리하는 것을 반복

    • 즉, 스레드는 작업을 하나 처리하고 일회용적으로 종료되는 것이 아니라, 계속 큐에 있는 작업을 가져와 처리

      ⇒ 제한된 갯수를 사용하더라도 충분히 작업들을 처리 가능

  • 애플리케이션이 작업 요청을 하기 위해 큐에 작업 내용 저장해 두면 → 스레드가 작업을 하나씩 가져와 처리 → 그 결과를 애플리케이션에 전달

    Untitled

ExecutorService, 즉, 스레드 풀의 동작 원리

Untitled

  • ExecutorService, 즉, 스레드 풀 안에는 작업을 저장하는 공간인 작업 큐가 있음
  • 작업 큐에 있는 작업을 가지고 와서 처리해 주는 스레드들이 제한된 갯수만큼 존재함
  • 애플리케이션은 스레드가 작업을 처리하도록 요청만 함
    • 스레드에서 실행할 수 있는 건 Runnable 객체

    • 애플리케이션은 단지 Runnable 이라는 객체를 만들어 작업 큐에 저장하기만 함

      → 작업 큐에 넣어진 Runnable 객체, 즉, 작업 객체는 자동적으로 스레드 풀에서 처리

  • 스레드는 작업 큐에 있는 작업을 가지고 처리 후 → 처리 결과를 애플리케이션으로 전달함
  • 애플리케이션은 이 결과 값을 받아 또 다른 작업 진행
  • 스레드 풀을 사용함으로써, 아무리 많은 작업 요청이 들어와도, 작업 큐의 작업량만 늘어날 뿐 스레드의 갯수가 늘어나는 것은 아님
  • 스레드는 제한된 갯수만 사용하고, 이를 가지고 작업 큐에 있는 작업들을 하나씩 처리함
  • 갑자기 많은 요청이 들어오면, 작업 큐의 용량만 커질 뿐 스레드의 갯수는 증가되지 않음 → 갑작스러운 애플리케이션의 성능 저하는 발생하지 않음
  • 스레드 풀은 서버 애플리케이션, 즉, 서버 프로그램을 만들 때 많이 사용함

Untitled

  • 스레드 풀은 Executors 클래스의 두 가지 정적 메서드 중 하나로 생성할 수 있음
  • 초기 스레드 수: 스레드 풀을 처음 만들 때 기본적으로 들어가 있는 스레드 수
  • 코어 스레드 수: 스레드 풀에 스레드가 증가되어 많은 스레드가 있을 경우, 사용되지 않는 스레드를 풀에서 제거하는데, 제거하지 않고 유지해야 하는 최소한의 스레드 수
  • 최대 스레드 수: 스레드 풀에서 스레드를 계속 생성할 때, 최대 생성할 수 있는 스레드 수
  • newCachedThreadPool()

    • 최대 스레드 수: 이론적으로 int 값의 최대 값 만큼 생성 가능()

      ⇒ 어디까지나 이론적인 얘기고, 실제로는 이 정도 생성되지 않고 메모리 상황에 따라 다름

    • 놀고 있는 스레드가 있으면 60초 제한 기준으로 풀에서 제거됨

  • newFixedThreadPool(int nThreads):
    • 한 번 생성된 스레드는 풀에서 제거되지 않고 계속 남아있음
    • 코어 스레드 개수 = 최대 스레드 개수이기 때문
    • 놀고 있는 스레드라 하더라도 개수가 줄지 않음
    1
2
3

      ExecutorService executorService = Executors.newFixedThreadPool(
    Runtime.getRuntime().availableProcessors(); // 최대 스레드 갯수
  );

    • availableProcessors(): 현재 CPU의 코어 수

      ⇒ 가장 이상적인 병렬 처리: CPU가 가진 코어 수 만큼 스레드를 만들어 씀

Untitled

  • newCachedThreadPool()와 newFixedThreadPool(int nThreads)는 내부적으로 ThreadPoolExecutor를 만들어 리턴함

    ⇒ 때문에 직접 ThreadPoolExecutor를 만들 수 있음

  • 스레드 풀을 직접 만들 경우 다양한 옵션을 줄 수 있음

Untitled

  • 멀티 스레드 애플리케이션은 최종 하나의 스레드가 종료되기 전까지, 애플리케이션은 종료되지 않음
  • 즉, 스레드 풀의 스레드가 계속 실행하고 있다면, 애플리케이션은 종료되지 않음
  • 따라서, 애플리케이션을 강제적으로 종료하고 싶다면, 스레드 풀을 종료해 모든 스레드를 종료해야 함
  • 스레드풀 종료 메서드
    • shouDownNow(): 미처리된 작업 때문에 가급적이면 사용하지 않는 편이 좋음
    • awaitTermination(): 시간 제한을 주고 중지

Untitled

  • Callable 객체를 만들 때 에는 리턴할 결과 값(애플리케이션이 받아야 할 결과 값)의 타입을 명시해 줌

Untitled

  • 작업 처리 요청: 애플리케이션이 작업 큐에 Runnable 또는 Callable 객체를 넣는 행위를 뜻함
  • 애플리케이션은 ExecutorService에 있는 execute(), submit() 메서드를 이용해 Runnable, Callable 객체를 작업 큐에 넣을 수 있음
  • 작업 처리 도중 예외가 발생할 경우
    • execute()
      • 스레드 자체가 종료됨 → 새로운 스레드를 만들어 갯수 유지
      • Runnable 객체를 처리하던 t1이라는 스레드에 예외가 발생했다면, t1은 스레드 풀에서 제거되고, t2가 새로 생성됨
    • submit()
      • 스레드를 제거하지 않고, 현재 작업 중인 작업을 버린 후 다음 작업을 가져와 계속 실행
      • Runnable1 객체를 처리하던 t1이라는 스레드에 예외가 발생했다면, t1은 현재 진행 중인 작업을 버리고 Runnable2를 처리함
      • 스레드는 재사용하는 게 좋음 → 스레드를 생성하게 되면 CPU와 메모리를 사용해야 하기 때문에

12.9 스레드풀(2)

실습 - 12.9.ExecuteSubmit4Exam.java

  • 예외 발생 시켜 보기 - execute() 의 경우
1
2
3
4
5
6
7
8
9
10
11
12
13
14

for (int i=0; i<10; i++) {
  Runnable runnable = new Runnable() {
    @Override
    public void run() {
      ThreadPoolExecutor threadPoolExecutor = (ThreadPoolExecutor) executorService;
      int poolSize = threadPoolExecutor.getPoolSize();
      String threadName = Thread.currentThread().getName();
      System.out.println("총 스레드 개수: " + poolSize + " / 작업 스레드 이름: " + threadName);
      int value = Integer.parseInt("삼"); // 예외 발생 지점
    }
  };
  executorService.execute(runnable);
  Thread.sleep(10);
}
  • 출력결과
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

총 스레드 개수: 1 / 작업 스레드 이름: pool-1-thread-1
Exception in thread "pool-1-thread-1" java.lang.NumberFormatException: For input string: "삼"
    at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
    at java.lang.Integer.parseInt(Integer.java:580) 
    at java.lang.Integer.parseInt(Integer.java:615) 
    at ExecuteSubmit4Exam$1.run(ExecuteSubmit4Exam.java:19)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
    at java.lang.Thread.run(Thread.java:748)        
총 스레드 개수: 2 / 작업 스레드 이름: pool-1-thread-3
Exception in thread "pool-1-thread-3" java.lang.NumberFormatException: For input string: "삼"
    at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
    at java.lang.Integer.parseInt(Integer.java:580) 
    at java.lang.Integer.parseInt(Integer.java:615) 
    at ExecuteSubmit4Exam$1.run(ExecuteSubmit4Exam.java:19)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
    at java.lang.Thread.run(Thread.java:748)        
총 스레드 개수: 2 / 작업 스레드 이름: pool-1-thread-2
Exception in thread "pool-1-thread-2" java.lang.NumberFormatException: For input string: "삼"
    at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
    at java.lang.Integer.parseInt(Integer.java:580) 
    at java.lang.Integer.parseInt(Integer.java:615) 
    at ExecuteSubmit4Exam$1.run(ExecuteSubmit4Exam.java:19)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
    at java.lang.Thread.run(Thread.java:748)        
총 스레드 개수: 2 / 작업 스레드 이름: pool-1-thread-4   
Exception in thread "pool-1-thread-4" java.lang.NumberFormatException: For input string: "삼"
    at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
    at java.lang.Integer.parseInt(Integer.java:580) 
    at java.lang.Integer.parseInt(Integer.java:615) 
    at ExecuteSubmit4Exam$1.run(ExecuteSubmit4Exam.java:19)
총 스레드 개수: 2 / 작업 스레드 이름: pool-1-thread-5
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
    at java.lang.Thread.run(Thread.java:748)        
Exception in thread "pool-1-thread-5" java.lang.NumberFormatException: For input string: "삼"
    at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
    at java.lang.Integer.parseInt(Integer.java:580) 
    at java.lang.Integer.parseInt(Integer.java:615) 
    at ExecuteSubmit4Exam$1.run(ExecuteSubmit4Exam.java:19)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
총 스레드 개수: 2 / 작업 스레드 이름: pool-1-thread-6
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
    at java.lang.Thread.run(Thread.java:748)        
Exception in thread "pool-1-thread-6" java.lang.NumberFormatException: For input string: "삼"
    at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
    at java.lang.Integer.parseInt(Integer.java:580) 
총 스레드 개수: 2 / 작업 스레드 이름: pool-1-thread-7   
    at java.lang.Integer.parseInt(Integer.java:615) 
    at ExecuteSubmit4Exam$1.run(ExecuteSubmit4Exam.java:19)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
    at java.lang.Thread.run(Thread.java:748)        
Exception in thread "pool-1-thread-7" java.lang.NumberFormatException: For input string: "삼"
    at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
    at java.lang.Integer.parseInt(Integer.java:580) 
    at java.lang.Integer.parseInt(Integer.java:615)
총 스레드 개수: 2 / 작업 스레드 이름: pool-1-thread-8   
    at ExecuteSubmit4Exam$1.run(ExecuteSubmit4Exam.java:19)
총 스레드 개수: 2 / 작업 스레드 이름: pool-1-thread-9   
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
    at java.lang.Thread.run(Thread.java:748)        
총 스레드 개수: 2 / 작업 스레드 이름: pool-1-thread-10
Exception in thread "pool-1-thread-9" 
Exception in thread "pool-1-thread-8" java.lang.NumberFormatException: For input string: "삼"
    at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
    at java.lang.Integer.parseInt(Integer.java:580)
    at java.lang.Integer.parseInt(Integer.java:615) 
    at ExecuteSubmit4Exam$1.run(ExecuteSubmit4Exam.java:19)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
    at java.lang.Thread.run(Thread.java:748)        
java.lang.NumberFormatException: For input string: "삼" 
    at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
    at java.lang.Integer.parseInt(Integer.java:580) 
    at java.lang.Integer.parseInt(Integer.java:615) 
    at ExecuteSubmit4Exam$1.run(ExecuteSubmit4Exam.java:19)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
    at java.lang.Thread.run(Thread.java:748)        
Exception in thread "pool-1-thread-10" java.lang.NumberFormatException: For input string: "삼"
    at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
    at java.lang.Integer.parseInt(Integer.java:580) 
    at java.lang.Integer.parseInt(Integer.java:615) 
    at ExecuteSubmit4Exam$1.run(ExecuteSubmit4Exam.java:19)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
    at java.lang.Thread.run(Thread.java:748)

  • 분석

    | thread-1 | | — |

    • 작업 큐에 작업이 쌓임 → 스레드 생성 → 작업 처리

      • 출력: 총 스레드 개수: 1 / 작업 스레드 이름: pool-1-thread-1

        ⇒ 예외 발생 → thread-1 스레드 종료 → 풀에서 제거됨

    | thread-3 | thread-2 | | — | — |

    • 작업 큐에 작업이 많이 쌓여있기 때문에, 스레드 풀은 최대 스레드 2개를 생성 → 작업 처리

      • 총 스레드 개수: 2 / 작업 스레드 이름: pool-1-thread-3

        ⇒ 예외 발생 → thread-3 종료 → 풀에서 제거됨

    | thread-2 | thread-4 | | — | — |

    • 스레드 풀은 개수를 유지하기 위해 새로운 스레드를 하나 더 생성, 스레드 풀은 최대 스레드 2개를 유지 → 작업 처리

      • 총 스레드 개수: 2 / 작업 스레드 이름: pool-1-thread-2

        ⇒ 예외 발생 → thread-2 종료 → 풀에서 제거됨

    | thread-4 | thread-5 | | — | — |

    • 이런 식으로 계속해서 스레드가 예외가 발생되면 제거되고, 새로 생성되며 최대 스레드 개수가 유지되며, 스레드 풀이 사용됨

      • 총 스레드 개수: 2 / 작업 스레드 이름: pool-1-thread-4

        ⇒ 예외 발생 → thread-4 종료 → 풀에서 제거됨

      • 총 스레드 개수: 2 / 작업 스레드 이름: pool-1-thread-5

        ⇒ 예외 발생 → thread-5 종료 → 풀에서 제거됨

  • 예외 발생 시켜 보기 - submit() 의 경우

1

executorService.submit(runnable);
  • 출력결과
1
2
3
4
5
6
7

총 스레드 개수: 2 / 작업 스레드 이름: pool-1-thread-2   
총 스레드 개수: 2 / 작업 스레드 이름: pool-1-thread-1   
총 스레드 개수: 2 / 작업 스레드 이름: pool-1-thread-2   
총 스레드 개수: 2 / 작업 스레드 이름: pool-1-thread-1   
총 스레드 개수: 2 / 작업 스레드 이름: pool-1-thread-2   
총 스레드 개수: 2 / 작업 스레드 이름: pool-1-thread-1   
총 스레드 개수: 2 / 작업 스레드 이름: pool-1-thread-2
  • 분석
    • 스레드 풀은 작업 큐에 작업이 쌓이면 자기가 가져올 수 있는 최대 스레드 수인 2개 만큼 스레드를 생성 시킴
    • 그래서 만들어진 게 thread-1, thread-2
    • 작업 큐에 있는 작업들을 thread-1, 2가 각각 가져와 처리
    • 중간 중간에 예외가 발생해도 스레드는 작업 큐에 있는 작업을 가져와 계속 처리함

Untitled

  • 블로킹 방식: 뭔가를 요청하고 나서 그 결과가 올 때까지 기다리는 방식

  • 결과 값이 없는 작업을 작업 큐에 저장하기 위해 submit() 메서드 사용

    1

      submit(Runnable task);

    → sumit() 메서드로 작업 객체(Runnable task)를 작업 큐에 넣고

    → 스레드가 이들 작업 객체(Runnable task)를 처리함

  • submit()은 Future라는 객체를 리턴함
  • Future 객체:
    • 작업 결과 X
    • 작업 결과가 나올 때까지 기다리는 객체 O

    • 지연 객체, 지연 완료 객체라고 부르기도 함

      ⇒ sumit() 메서드가 호출되면 그 즉시 Future 객체가 리턴됨

      ⇒ 즉, 스레드가 Runnable 또는 Callable 의 코드를 실행하지 않은 상태에서 Future 객체가 얻어지는 것

      ⇒ 때문에, Future는 작업 결과가 아니라, 작업이 스레드에서 처리가 완료된 후의 그 결과 값을 받을 목적으로 만들어진 객체임

      ⇒ 결과가 나중에 나오기 때문에 지연 객체라고 함

Untitled

  • get(): 작업이 완료될 때까지 블로킹 되었다가(스레드가 작업을 완료할 때까지 기다렸다가) 처리 결과 V를 리턴

  • Runnable 객체를 담는 submit()은 결과값이 없는 작업을 처리할 때 쓰이는 메서드임

    1

      submit(Runnable task); // 결과 값이 없는 작업(Runnable task)을 작업 큐에 넣는다(submit)
    • 스레드가 실행이 다 되고, 작업 처리를 완료한다면, 결과가 없기 때문에 future.get()은 결국 null을 리턴함
    1

      submit(Runnable task, Integer result);
    • 두 번째 매개 값인 Integer result가 결과 값
    • 즉, future.get()은 int 타입 값을 리턴
    1

      submit(Callable<String> task);
    • submit()에 Callable 객체를 저장할 때, 그 값을 String으로 지정하면, Callable의 작업 처리 결과가 String으로 나옴
    • 즉, future.get()은 String 타입 값을 리턴

  • 스레드에서 Runnable, Callable 객체를 처리할 때 예외가 발생 시

    ⇒ get() 메서드는 처리 결과가 리턴될 때까지 기다리는데, 스레드가 작업 처리를 하는 도중에 예외 발생 시, get() 메서드에서도 예외가 발생함

    ⇒ 예외 발생 시 결과 값을 얻을 수 없기 때문에, get() 메서드는 예외가 발생하도록 되어 있음

Untitled

  • Future의 get() 메서드는 블로킹이 되기 때문에, 스레드가 작업을 완료할 때까지 이 get()은 멈춰 있음

    ⇒ 때문에, get()은 UI를 생성하거나 변경하는 스레드에서 호출하면 안 됨

    ⇒ UI가 멈춰있는 상태가 되기 때문 → 이벤트 처리를 할 수 없게 됨

  • 그렇다면 get() 메서드를 어떻게 호출해야 하느냐?
    • 새로운 스레드를 생성해서 호출하거나
    1
2
3
4
5
6
7
8
9
10
11

      // 1. 스레드 객체를 생성하고
  new Thread(new Runnable() { // 2. 매개값으로 Runnable 객체 지정
    @Override
    public void run() { // 3. run() 재정의
      try {
        future.get(); // 4. future.get() 메서드를 호출하도록
      } catch(Exception e) {
        e.printStackTrace();
      }
    }
  }).start(); // 5. start()로 새로운 스레드가 run()을 실행하도록 함
    • 스레드풀의 스레드가 호출하도록 해 주거나
    1
2
3
4
5
6
7
8
9
10
11
12

      // 3. submit() 이라는 메서드로 작업 큐에 넣어 줌
  executorService.submit(new Runnable() { // 2. 작업 객체를 만들어서
    @Override
    public void run() {
      try {
        future.get(); // 1. 이것을 처리하는,
      } catch(Exception e) {
        e.printStackTrace();
      }
    }
  });
  // 4. 스레드가 작업 큐에 들어간 작업을 처리하며, run()이 실행됨

    ⇒ 이런 방법은 UI 생성, 변경, 이벤트 처리하는 스레드에서 future.get()이 실행되지 않기 때문에 문제되지 않음

  • 다른 메서드: Future의 또 다른 메서드
    • cancel(boolean mayInterruptIfRunning): 스레드 작업 도중 취소
      • boolean mayInterruptIfRunning: 필요한 경우 interrupt를 할 것인가(true - 스레드에 interrupt 호출, interruptException 발생됨)
    • isCancel(): 보통 cancel()로 작업 취소 후 확인용

Untitled

  • 리턴값이 없는 작업 완료 통보

    ⇒ 리턴값이 없는 작업을 만들어서 → 작업 큐에 넣음 → 스레드가 작업 큐에서 작업을 가져와 처리 → 처리 후 완료를 통보

    1
2
3
4
5
6
7
8
9
10

      // 1. 리턴값이 없는 작업 객체 생성
  Runnable task = new Runnable() {
    @Override
    public void run() {
        // 2. 스레드가 처리할 작업 내용
    }
  }
  Future future = executorService.submit(task);
  // 3. 스레드 풀(executorService)의 submit() 메서드에 작업 객체 삽입
  // 4. submit()은 3. 이후 즉시 Future 객체 리턴
    • future를 가지고 스레드가 작업을 완료했는지, 처리 도중인지 알 수 있음
    1
2
3
4
5
6
7
8
9

      try {
    future.get(); // get()을 호출하게 되면 블로킹 발생 -> 작업을 완료할 때까지 (해당 코드를 실행하는)스레드는   여기서 멈춰있음
    // Runnable 객체에 리턴값이 없기 때문에 여기서 리턴값을 받을 필요는 없음
    // 여기서의 get() 은 '스레드가 작업을 완료할 때까지 기다린다'는 의미
  } catch(InterruptedException e) {
    // 작업 처리 도중 스레드가 interrupt 될 경우 실행할 코드
  } catch(ExecuteException e) {
    // 작업 처리 도중 예외가 발생된 경우 실행할 코드
  }

    Untitled

    • 스레드 풀(pool) 안에 Runnable이라는 작업이 있음
    • 이 작업을 스레드 풀의 스레드가 ↓ 이렇게 실행
    • 실행 동안, get() 메서드는 블로킹됨
    • 실행이 완료가 되면, 즉 풀의 스레드가 Runnable 객체의 run() 메서드를 다 실행하게 되면, 비로소 future.get() 결과가 리턴됨
    • 즉, future.get()이 블로킹에서 빠져나옴
    • 하지만, 작업 결과가 없기 때문에 future.get()은 null이 리턴됨

  • 발생할 수 있는 예외의 종류

    ↓ (스레드 실행) 작업 도중 interrupt() 호출: InterruptedException e
    ↓ (스레드 실행)  
    ↓ (스레드 실행) 작업 도중 예외 발생: ExecuteException e

실습 - 12.9.blocking

Untitled

  • main 스레드 실행 방향

Untitled

  • 스레드 풀의 스레드가 Runnable 작업 객체 내 run()을 계속 실행 → 실행이 끝나면,

Untitled

  • 비로소 get()은 리턴 됨
  • main 스레드는 get()을 호출한 시점에 블로킹 됨 → pool에서 run()이 완전히 종료되면 future.get(); 부분의 블로킹이 풀림
  • 이 후 코드 순차 실행

12.9 스레드풀(3)

Untitled

  • 리턴 값이 있는 작업일 경우, Callable 이라는 객체를 만듦
  • T에는 리턴값 타입을 지정
  • Callable이 가지고 있는 메서드 call()을 재정의
  • 이 call() 메서드 내 내용이 결국 스레드에서 실행할 내용
  • call() 메서드는 리턴 값이 있기 때문에 리턴 타입 T를 지정
  • call() 메서드에서 예외가 발생할 수 있기 때문에 throws Exception 추가
1

Future<T> future = executorService.submit(task);
  • 만들어진 Callable 작업 객체를 submit() 이라는 메서드를 사용해 작업 큐에 넣음
  • submit() 메서드에 Callable 객체 task를 삽입
  • 그러면 submit()은 그 즉시 Future 객체 리턴
  • Future가 나중에 얻게 될 결과값의 타입은 T
  • 결국, Callable의 T와 Future의 T는 같은 타입
1

future.get();
  • Future의 get() 메서드를 호출하면, 스레드는 call() 메서드를 다 실행할 때까지 기다림(블로킹)
  • call() 모두 실행 후, get()은 리턴 값 T를 리턴함
  • 즉, call()의 리턴 값을 get()이 T result에 리턴하는 것

Untitled

  • 작업 처리 결과는 스레드에서 만들어짐

    ⇒ 결과 값을 스레드가 아닌 외부 객체에 저장하는 경우

  • 스레드 1과 스레드 2에서 각각 처리된 작업의 결과를 취합하고 싶을 때

    ⇒ 이런 경우 스레드가 처리한 작업의 결과를 → 외부 객체에 저장

1
2
3

Result result = ...; // 스레드 1, 2가 공통적으로 사용하는 공유 객체
Runnable task = new Task(result); // 작업 객체를 만들고, result를 매개 변수로 삽입해 작업 내용에서 쓸 수 있도록 함
  • 작업 객체에 result를 넣어주는 이유: 스레드가 Runnable task 작업을 처리하고 나서 처리 결과를 result에 누적 시키려면, 스레드는 result의 참조를 알고 있어야 하기 때문에
1
2
3
4
5
6
7
8

// submit(task, result)에 지정된 타입이 result이기 때문에 Future<Result>가 됨
Future<Result> future
  = executorService.submit(task, result);
  // submit() 호출하고, 
  // 첫번째에 작업 객체, 
  // 두번째에 result를 넣어 줌: 나중에 future.get()으로 얻을 결과 값이 결국 result 타입이라는 것을 지정하는 것
// submit은 즉시 future 리턴
result = future.get(); // get() 호출 시, get()은 result 타입 결과 값을 리턴함
  • result의 타입이 결국 Future의 T와 같아야 하며, get()이 리턴하는 결과 값의 타입 또한 result와 동일한 타입임
1
2
3
4

Runnable task = new Task(result);
↓
↓
↓

1
2
3
4
5
6
7
8
9
10

// Runnable task를 만드는 방법
class Task implemetns Runnable {
  Result result; // new Task(result); 로 받은 result를 필드에 저장
  Task(Result result) { this.result = result; } // 필드에 전달된 값을 저장
  @Override
  public void run() { // run() 재정의
    // 작업 코드
    // 처리 결과를 result 저장
  }
}

실습 - 12.9.result

Untitled

  • 세 번째 submit()이 외부 객체에 결과값을 저장하는 메서드

12.9 스레드풀(4)

Untitled

  • 작업 요청 순서: 작업 큐에 저장된 순서
  • 먼저 요청한 작업: 작업 큐에 먼저 들어온 작업
  • 여러 개의 작업들이 순차적으로 처리될 필요성이 없음 → 작업들이 독립적이라는 뜻
  • 작업 큐에 있는 작업들은 모두 독립적이고, 그 작업들이 순서와는 상관없이 처리 결과가 나온다면 처리 결과가 빨리 나오는 것부터 이용하는 것이 좋음
  • poll():
    • get() 과 비슷하나 완료된 작업의 Future를 가져옴
    • 완료된 작업이 없다면 즉시 null 리턴 → 블로킹이 아니라는 뜻
    • poll()을 실행하는 시점에서, 완료된 작업이 있으면 가져오거나 null 리턴하는 것
  • poll(long timeout, TimeUnit unit): timeout 시간 동안 기다렸다가, 즉 블로킹 되었다가 완료된 작업이 있으면 가져옴
  • take(): 완료된 작업이 없으면 계속 대기 상태, 완료된 작업이 생기면 그 때 리턴이 되어 Future 를 얻어 옴

Untitled

1
2
3
4
5
6
7
8
9
10

// 스레드 풀 객체 ExecutorService 생성
ExecutorService executorService = Executors.newFixedThreadPool(
  Runtime.getRuntime().acailableProcessors()
);

CompletionService<V> completionService 
  // new ExecutorCompletionService<V> 객체 생성
  = new ExecutorCompletionService<V>( // V: 스레드 풀이 작업을 다 처리하고나서 생성된 결과 타입을 지정
  executorService // 매개값: 스레드 풀 객체
);
  • poll()과 take() 메서드를 이용해 처리 완료된 작업의 Future을 얻으려면

  • completionService의 submit() 메서드로 작업 처리 요청을 해야 함

    ⇒ executorService의 submit()을 이용하면 안 됨

    ⇒ 작업 큐에 작업을 저장할 때 executorService가 아닌 completionService를 사용해야 poll()과 take() 이용 가능

    1
2
3

      CompletionService<V> completionService = new ExecutorCompletionService<V>( 
    executorService 
  );

    1
2

      completionService.submit(Callable<V> task); // completionSerivice.submit()를 이용해 Callable task를 작업 큐에 넣어 줌
  completionService.submit(Runnable task, V result);// completionSerivice.submit()를 이용해 Runnable을 작업 큐에 넣어 주고, 외부 객체 값도 넣어 줌

Untitled

  • take()는 완료된 작업이 있을 때까지 블로킹됨
  • 블로킹되기 때문에, 결국은 스레드에서 이 take()를 호출함
  • UI를 생성하거나 변경하는 스레드에서 take()를 호출하면, 작업이 완료될 때까지 블로킹, 즉 멈추기 때문에, UI 작업을 할 수 없음
  • UI 작업 이외에서 take()를 호출하는 것이 바람직함
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// 스레드 풀의 스레드 executorService가 take() 를 사용해 완료된 작업을 처리하는 예제

executorService.submit(new Runnable() { // 작업 객체인 Runnable 생성
  @Override
  public void run() { // 재정의
    while(true) {
      try {
        Future<Integer> future = completionService.take(); // 스레드 풀의 스레드가 완료한 작업이 있을 때 그 작업의 Future를 리턴(반복)
        int value = future.get(); // 그 작업의 결과를 얻어 이용(반복)
        System.out.println("처리 결과:" + value);
      } catch(Exception e) {
        break;
      }
    }
  }
});

실습 - 12.9.CompletionService

Untitled

  • 스레드 풀 안의 작업 큐에 c1, c2, c3 작업들이 순서대로 들어 왔다고 가정
  • 이 작업들을 스레드 t1, t2가 하나씩 처리함
  • 그러나, 반드시 c1이 먼저 끝난다는 보장이 없음
  • c2가 t2에 의해 먼저 결과가 나올 수도 있음
  • 스레드의 실행 환경, 생성 시간 때문에 먼저 작업 큐에 들어간 Callable이 먼저 처리가 끝나는 것이 아님
  • c1, c2, c3는 모두 독립성을 가지고 있고, 어떤 작업이 끝나더라도 상관 없는 경우 완료된 작업을 알아내 그 작업을 처리해 주는 것이 효율적임

Untitled

  • 블로킹 방식: future 객체를 이용하는 방식

    • (1) main 스레드가 스레드 풀에게 작업 처리 요청(submit)

      → 스레드 풀이 작업을 받아 처리

      → (2) submit()은 즉시 Future 객체 리턴

      → (3) main 스레드는 Future를 이용해 get() 호출

      → get()은 스레드 풀의 (4) 스레드가 작업 처리를 완료할 때까지 블로킹

      → 작업이 완료되면 결과를 받음

      → (5) 그 다음 코드 실행

  • 콜백 방식: 자동적으로 메서드가 호출되는 방식

    • (1) main 스레드가 스레드 풀에게 작업 처리 요청(submit)

      → 스레드 풀이 작업을 받아 처리

      → (2) submit()은 즉시 Future 객체 리턴

      → Future를 이용하지 않고, (3) main 스레드는 일단 작업 처리 요청만 하고 자기 할 일을 계속 수행함

      → 스레드 풀의 스레드가 작업 처리를 완료하면, 자동적으로 콜백 메서드를 실행, (4) 이 콜백 메서드의 작업을 수행

    • main 스레드가 future.get()을 호출해 작업 처리가 끝날 때까지 기다리는 것이 아니라, 자기 할 일을 계속 함
    • 스레드 풀의 스레드가 작업을 완료하게 되면 자동적으로 콜백 메서드를 실행하게 함
    • 콜백 메서드 내에서 작업을 처리한 결과를 가지고 이용하도록 함

Untitled

  • 콜백 방식을 이용하려면 먼저 콜백 객체를 생성해야 함
  • java.nio.channels.CompletionHandler: 콜백 객체를 만들기 위한 인터페이스
  • 꼭 이 객체를 사용할 필요는 없음(하나의 예시)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// V: 스레드가 작업을 처리한 이휴의 결과값
// A: 콜백 메서드에서 사용할 수 있는 첨부 객체
CompletionHandler<V, A> callback
  = new CompletionHandler<V, A>(){ // 익명 객체로 구현 객체 생성
  @Override
  public void completed(V result, A attachment) {
      // 처리를 완료했을 때 시행하는 콜백 메서드
      // V: 스레드가 처리한 결과값
      // A: CompletionHandler<V, A>에서 지정한 A 객체(첨부객체)
  }
  @Override
  public void failed(Throwable exc, A attachment) {
      // 스레드가 처리를 실패하거나 예외가 발생했을 때 시행하는 콜백 메서드
      // Throwable exc: 예외
      // A attachment: 첨부 객체
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// 작업객체 생성
Runnable task = new Runnable() {
  @Override
  public void run() {
    try {
      // 작업 처리
      V result = ...;
      callback.completed(result, null); // 필요한 시점에 콜백 객체의 콜백 메서드 호출
      // 이 콜백 메서드를 실행함으로써 결과를 애플리케이션에서 이용하도록 할 수 있음
    } catch(Exception e) {
      callback.failed(e, null); // 필요한 시점에 콜백 객체의 콜백 메서드 호출
      // 작업 처리 중 예외 발생 시, 콜백 객체의 failed() 메서드를 호출해 예외 발생 시 애플리케이션이 처리해야 할 코드를 실행
    }
  }
}
  • 콜백 메서드를 실행하는 것은 main 스레드가 아니라, 스레드 풀의 스레드임
1
2
3
4
5
6
7
8
9
10

CompletionHandler<V, A> callback = new CompletionHandler<V, A>(){
  @Override
  public void completed(V result, A attachment) {
    // ui 생성, 변경 메서드를 이 위치에서 작성할 시 에러 발생
  }
  @Override
  public void failed(Throwable exc, A attachment) {
    // ui 생성, 변경 메서드를 이 위치에서 작성할 시 에러 발생
  }
}

  • 콜백 메서드를 실행하는 것은 스레드 풀의 스레드이므로, 콜백 메서드 안에 UI 생성, 변경 메서드를 작성하면 에러가 발생

    ⇒ 자바 FX, 안드로이드 X의 경우, UI 생성 및 변경 코드는 UI 스레드에서 다뤄야 함

참고자료

강의교안_12장.ppt

Back, Java
Back Java
This post is licensed under CC BY 4.0 by the author.
Contents