아이템 81. wait 과 notify 보다는 동시성 유틸리티를 이용하라.

[Irisation23]

• 0. TL;DR 📚
• 1. wait 과 notify
• 2. 고수준 동시성 유틸리티
  • 2.1 실행자 프레임워크
  • 2.2 동시성 컬렉션
    • 상태 의존적 메서드
    • Collections.synchroizedXXX
• 3. 동기화 장치
  • BlockingQueue
  • 동기화 장치의 종류
• 3. wait와 notify 메서드를 사용해야하는 상황은?
  • 3.1 wait()
  • 3.2 notify()
• 4. 핵심 정리 📚
• 5. 회고 🧹

Table of contents generated with markdown-toc

---

0. TL;DR 📚

• wait 과 notify는 개발자가 컨트롤하기에 쉽지않으니 고수준 동시성 유틸리티를 사용하자.

1. wait 과 notify

해당 키워드들은 스레드의 상태 제어를 위한 메서드이다.

• wait() 은 가지고 있던 고유 락을 해제하고, 스레드를 잠들게 하는 역할을 한다.
• notify() 는 잠들어 있던 스레드 중 임의로 하나를 골라 깨우는 역할을 하는 메서드이다.

public class ThreadB extends Thread{
   // 해당 쓰레드가 실행되면 자기 자신의 모니터링 락을 획득
   // 5번 반복하면서 0.5초씩 쉬면서 total에 값을 누적
   // 그후에 notify()메소드를 호출하여 wait하고 있는 쓰레드를 깨움
    @Override
    public void run(){
        synchronized(this){
            for(int i=0; i<5 ; i++){
                System.out.println(i + "를 더합니다.");
                total += i;
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            notify(); // wait하고 있는 쓰레드를 깨움
        }
    }
}

public class ThreadA {
    public static void main(String[] args){
        // 앞에서 만든 쓰레드 B를 만든 후 start 
        // 해당 쓰레드가 실행되면, 해당 쓰레드는 run메소드 안에서 자신의 모니터링 락을 획득
        ThreadB b = new ThreadB();
        b.start();

        // b에 대하여 동기화 블럭을 설정
        // 만약 main쓰레드가 아래의 블록을 위의 Thread보다 먼저 실행되었다면 wait를 하게 되면서 모니터링 락을 놓고 대기       
        synchronized(b){
            try{
                // b.wait()메소드를 호출.
                // 메인쓰레드는 정지
                // ThreadB가 5번 값을 더한 후 notify를 호출하게 되면 wait에서 깨어남
                System.out.println("b가 완료될때까지 기다립니다.");
                b.wait();
            }catch(InterruptedException e){
                e.printStackTrace();
            }

            //깨어난 후 결과를 출력
            System.out.println("Total is: " + b.total);
        }
    }
}

출력 결과

• 위의 코드를 참조해 보면 wait과 notify의 올바른 이용이 까다롭다.
• 따라서 고수준 동시성 유틸리티를 이용한다.

2. 고수준 동시성 유틸리티

고수준 동시성 유틸리티는 3종류로 나눌 수 있다.

1. 실행자 프레임워크
2. 동시성 컬렉션(Concurrent Collection)
3. 동기화 장치 (synchronizer)

2.1 실행자 프레임워크

아이템 80. 에서 다뤄지는 내용을 참조.

2.2 동시성 컬렉션

표준 컬렉션(List, Queue, Map) + 동시성 = 동시성 컬렉션( CopyOnWriteArrayList , ConcurrentHashMap, ConcurrentLinkedQueue)참조 자료 자바독

동시성 컬렉션의 동시성을 무력화하는 것은 불가능하며, 외부에서 락을 걸어오면 속도가 느려진다.
동시성을 무력화하지 못하므로 여러 메서드를 원자적으로 묶어 호출할 수 없다.

동시성을 무력화하지 못하므로 여러 메서드를 원자적으로 묶어 호출할 수 없다??

한 번에 여러 가지 일을 처리하는 코드를 작성할 때, 다른 스레드에서 동시에 접근해서 문제가 발생할 가능성이 있는 경우, 이를 방지하기 위해 여러 메서드를 하나의 묶음으로 호출하는 것이 불가능하다는 것을 의미함. 다시 말해, 동시성 문제를 해결하기 위해서는 적절한 동기화 기법을 사용하여 각각의 메서드가 원자적으로 실행되도록 해야 함.

상태 의존적 메서드

위의 문제를 해결하기 위해 여러 기본 동작들을 하나로 묶는 상태 의존적 메서드를 이용할 수 있다.

putIfAbsent("key") // 키에 매핑된 값이 없을 때에만 새 값을 집어넣고, 없으면 그 값을 반환한다.

Collections.synchroizedXXX

Collections에서 제공해주는 synchronizedXXX() 를 사용하여 동기화한 컬렉션을 만드는 것 보다는 동시성 컬렉션을 사용하는 것이 성능적 이점을 볼 수 있다.

3. 동기화 장치

컬렉션 인터페이스 중 일부는 작업이 성공적으로 완료될 때 까지 기다리도록 확장되었다.

BlockingQueue

public interface BlockingQueue<E> extends Queue<E> {
     /**
      * 이 큐의 헤드를 가져오고, 요소가 사용 가능해질 때까지 대기합니다.
      * @return 이 큐의 헤드
      * @throws InterruptedException 대기 중 인터럽트가 발생한 경우
     */
    E take() throws InterruptedException;
}

BlockingQueue의 take() 는 큐의 원소를 꺼내는 역할을 하는데, 만약 큐가 비어있다면 새로운 원소가 추가될 때까지 기다린다.
ThreadPoolExcutor를 포함한 대부분의 실행자 서비스 (아이템 80.) BlocingQueue를 사용한다.

동기화 장치의 종류

• CountDownLatch, Semaphore
  • 사용 빈도가 높다.
• CylicBarrier, Exchanger
  • 상대적으로 덜 쓰인다.
• Phaser
  • 가장 강력하다.

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

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

    ExecutorService executorService = Executors.newFixedThreadPool(5);
    try {
      long result = time(executorService, 3, () -> System.out.println("hello"));
      System.out.println("총 걸린 시간 : " + result);
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      executorService.shutdown();
    }
  }

  public static long time(Executor executor, int concurrency, Runnable action) throws InterruptedException {
    CountDownLatch ready = new CountDownLatch(concurrency);
    CountDownLatch start = new CountDownLatch(1);
    CountDownLatch done = new CountDownLatch(concurrency);

    for (int i = 0; i < concurrency; i++) {
      executor.execute(() -> {
        ready.countDown(); // 타이머에게 준비가 됐음을 알린다.
        try {
          // 모든 작업자 스레드가 준비될 때까지 기다린다.
          start.await();
          action.run();
        } catch (InterruptedException e) {
          Thread.currentThread().interrupt();
        } finally {
          // 타이머에게 작업을 마쳤음을 알린다.
          done.countDown();
        }
      });
    }

    ready.await(); // 모든 작업자가 준비될 때까지 기다린다.
    long startNanos = System.nanoTime();
    start.countDown(); // 작업자들을 깨운다.
    done.await(); // 모든 작업자가 일을 끝마치기를 기다린다.
    return System.nanoTime() - startNanos;
  }
}

실행 결과

executor는 concurrency 매개변수로 지정한 값(위 코드에서는 3)만큼의 스레드를 생성할 수 있어야 한다. 그렇지 않으면 메서드 수행이 끝나지 않는데 이를 스레드 기아 교착 상태라고 한다.

기아 교착 상태?

기아 상태(Starvation)
특정 프로세스의 우선순위가 낮아서 원하는 자원을 계속 할당 받지 못하는 상태를 말합니다.
교착 상태는 여러 프로세스가 동일 자원 점유를 요청할 때 발생하고, 기아 상태는 여러 프로세스가 부족한 자원을 점유하기 위해 경쟁할 때, 특정 프로세스는 영원히 자원 할당이 안되는 경우에 주로 발생합니다.
기아 상태를 해결하기 위해서는 우선순위를 변경해주면서 해결할 수 있습니다.

• 시간을 잴 때는 시스템 시간과 무관한 System.nanoTime을 사용하는 것이 더 정확하다.

3. wait와 notify 메서드를 사용해야하는 상황은?

두가지 조건을 지켜 사용해야한다.

1. 반드시 동기화 영역 안에서 사용해야 한다.
2. 항상 반복문 안에서 사용해야 한다.

3.1 wait()

synchronized (obj) {
    while (조건이 충족되지 않았다) { // 조건이 충족될 때까지 while 문에서 잡아둔다.
        obj.wait(); // 락을 놓고, 깨어나면 다시 잡는다.
    }

    ... // 조건이 충족됐을 때의 동작을 수행한다.
}

반드시 반복문 밖에서는 절대 호출하면 안된다. 또한 대기 전에 조건을 검사하여 조건이 이미 충족되었다면 wait을 피해야 하는데, 이는 응답 불가 상태를 예방하기 위해서이다.

한편, 대기한 이후의 조건을 검사하여 조건을 충족하지 않았을 때 다시 대기하게 하는 경우도 있는데, 이는 조건이 만족되지 않아도 스레드가 깨어날 수 있는 상황이 있기 때문이다. (안전 실패 예방)

• notify를 호출하여 대기 중인 스레드가 깨어나는 사이에 다른 스레드가 락을 거는 경우
• 조건이 만족되지 않았지만 실수 혹은 악의적으로 notify를 호출하는 경우
• 대기 중인 스레드 중 일부만 조건을 충족해도 notifyAll로 모든 스레드를 깨우는 경우
• 대기 중인 스레드가 드물게 notify 없이 깨어나는 경우. 허위 각성(spurious wakeup)이라고 한다.

3.2 notify()

일반적으로 notify()보다는 notifyAll()을 사용하는 것이 안전하다.

---

4. 핵심 정리 📚

• 코드를 새로이 작성한다면 wait과 notify를 사용하기 보다는 고수준 동시성 유틸리티를 고민해보자.
• 만약 사용한다면 wait은 while문 안에서 잡아두고 통제해 두자.
• 일반적으로 notify() 보다는 notifyAll()을 이용하자.

---

5. 회고 🧹

2023-04-02 일

• 스레드 개념과 동시성 개념은 Java2 이라 생각한다.
• 자바가 객체지향적인 관점에서 작성된 언어고 플랫폼이라면 스레드와 동시성은 그 안에서 이뤄지는 또 다른 작업이라 생각된다. (e.g - 거상의 사천성)
• 사실 이펙티브 자바에서 다뤄지는 해당 주제는 손쉽게 한번 읽고 적용할 주제가 아니라 생각된다.
• 끊임없이 체화를 통해 해당 기술이 어떤 인과관계를 가지고 있으며 내가 부딪힌 상황에서 고려해야할 점에 대해 파악해야 한다 생각한다.

---

출처

https://gold-dragon.tistory.com/263
https://github.com/Meet-Coder-Study/book-effective-java/blob/main/11%EC%9E%A5/81_wait%EC%99%80_notify%EB%B3%B4%EB%8B%A4%EB%8A%94_%EB%8F%99%EC%8B%9C%EC%84%B1_%EC%9C%A0%ED%8B%B8%EB%A6%AC%ED%8B%B0%EB%A5%BC_%EC%95%A0%EC%9A%A9%ED%95%98%EB%9D%BC_%EC%8B%A0%EC%84%A0%EC%98%81.md