Thread Pool.md

목차

• 목차
• 들어가며
• ThreadPool이 등장하게 된 배경
  • ThreadPool을 사용하지 않는다면
  • ThreadPool을 사용한다면
  • ThreadPool의 문제점과 사용시 주의할 점
• ThreadPool은 어떻게 동작하는가?
• Thread Pool In Java
  • 스레드 풀 추상화 - Executor와 ExecutorService
  • Executor vs ExecutorService
  • ThreadPool 사용 예시
• ExecutorService
  • ExecutorService 구현체
  • 꼭 Shutdown을 해줘야한다
  • invokeAny() vs invokeAll()
  • Task Cancel
• 마치며
• 참고

들어가며

이전 글에서 Thread에 대한 기본 개념과 Thread In Java에 대해서 다뤘다면 이번 글에선 ThreadPool에 대한 기본 개념과 자바에선 어떻게 사용되는지 다룬다.

우선 ThreadPool에 대한 기본적인 개념에 대해서 다루고, Java에서 ThreadPool을 다루기 위해 꼭 알아야하는 Executor와 ExecutorService에 대해서 정리하였다.

ThreadPool이 등장하게 된 배경

ThreadPool을 사용하지 않는다면

❗️ ThreadPool을 사용하지 않는다면

많은 프로그램은 스레드를 이용하여 병렬 (혹은 병행)처리를 한다.

문제는 점차 필요한 스레드의 개수가 많아지면서, 잦은 스레드 생성과 스케줄링으로 인해 CPU와 메모리 사용량이 증가한다.

각 스레드는 메모리(RAM)과 같은 특정 수준의 컴퓨터 리소스를 사용하기 때문에 동시에 너무 많은 스레드가 활성된다면 컴퓨터의 속도가 저하된다.

또한 스레드의 생성 개수를 제어하기 힘들기 때문에 자칫하면 컴퓨터가 멈출 수도 있다.

예를 들어, 메모리(RAM)이 너무 많이 소모되어 OS가 RAM을 Disk로 스왑아웃하기 시작하면 속도는 현저히 느려진다.

물론 스레드 생성뿐만 아니라 회수도 해야한다..

❗️ 자바 스레드의 문제

자바 스레드는 직접 운영체제 스레드에 접근한다. 이때 스레드를 생성하고 회수하는 비용은 생각보다 크며, 더욱이 운영체제 스레드의 숫자는 제한되어있다.

만약 운영체제가 제공하는 스레드 개수이상의 스레드를 생성하여 사용한다면 자바 애플리케이션이 예상치 못하게 크래시될 수 있다.

ThreadPool을 사용한다면

👍 ThreadPool을 사용한다면

ThreadPool의 핵심은 스레드 재사용이다.

ThreadPool을 사용하지 않는 기존의 Thread 전략은 한번 사용하면 종료되고 다시 만들어애했다.

하지만 ThreadPool은 정해진 숫자만큼 만들어둔 기존 스레드를 종료시키지않고 계속해서 작업을 맡겨 실행하게 된다.

스레드를 미리 만들어두고 작업이 들어올면 스레드들에게 작업을 적절히 분배한다.

🤔 그래서 뭐가 좋다는건데? - Thread Pool의 장점

결론적으론 정해진 숫자의 기존 스레드를 재사용하기 때문에 리소스 사용량을 절약하고, 총 처리량도 더 높일 수 있다.

1. 스레드 풀을 사용하면 한 번에 활성 상태인 스레드 수를 쉽게 제어할 수 있다. 이를 통해 스레드의 생성과 회수로 인한 부하를 줄일 수 있다.
2. 한 번에 많은 요청이 들어올 때 빠르고 효율적으로 동시 작업을 수행할 수 있다.

ThreadPool의 문제점과 사용시 주의할 점

❗️ 그렇다고 좋은 것만은 아니다 - Thread Pool의 단점

1. 메모리 낭비
   • ThreadPool은 Thread를 미리 만들어두고 재사용한다는 측면에서 굉장히 유용한 솔루션이다.
   • 하지만 몇 개의 Thread를 미리 만들어둘지가 중요하다. 만약 너무 많은 스레드를 만들어둔다면 메모리만 차지하고 아무것도 하지 않는 스레드가 존재할 수도 있다.
2. 놀고먹는 스레드 발생 가능성
   • 병렬적으로 처리요청을 한다면 한 스레드는 요청을 처리하느라 허덕이고 있는와중에 다른 스레드는 놀고있을 수 있다.
   • 이로인해 미리 만들어둔 스레드를 잘 활용하지 못할 수도 있는 문제가 있다.
   • 물론 이는 자바에서는 ForkJoinPool을 지원한다.
3. 놀고먹거나 I/O 혹은 네트워크 연결을 기다리는 스레드 사용시 주의해야한다.
   • 스레드가 잠을 자거나 I/O 혹은 네트워크 연결을 기다리면 해당 Task를 실행하는 스레드는 Blocking될 확률이 높다. 즉, 스레드를 할당받았으면서 아무 작업도 하지않고있는 것이다.
   • 그러므로 가능한 Blocking (자거나 이벤트를 기다리는)을 발생시키는 Task는 스레드 풀을 이용하지않는게 좋다. (물론 이는 지키기어렵다...)
4. DeadLock
   • ThreadPool만의 문제라기보다는 멀티스레딩 환경에서 발생할 수 있는 대표적인 문제점은 데드락이다. ThreadPool도 데드락이 발생할 수 있다.
   • ThreadPool에 경우, 만약 하나의 Task의 결과를 기다리는 또 다른 Task를 Queue에 넣으면 데드락이 발생할 확률이 높다.
5. 스레드 없어짐 문제
   • ThreadPool에 미리 생성된 스레드가 요청을 처리하고나서 다시 대기상태가 안되고 제거될 수 있다. (재사용 불가)
   • 예를 들어, 스레드에 할당된 Task가 예외를 던졌는데 해당 예외를 잡지 못한다면 Thread 자체가 종료되기 때문에 ThreadPool에서 스레드의 개수가 하나씩 줄어들 수 있다.

ThreadPool은 어떻게 동작하는가?

출처: https://www.logicbig.com/tutorials/core-java-tutorial/java-multi-threading/thread-pools.html

사실 위 그림만봐도 ThreadPool이 어떻게 동작하는지 알 수 있다. 그래도 조금 글로 정리하자면 다음과 같다.

• ThreadPool에 요구에 맞는 스레드를 재사용하기 위해 미리 생성해둔다. (New ThreadPool)
• 새로운 작업이 들어올 때마다 TaskQueue에 넣는다. (New Task)
• TaskQueue에서 하나씩 꺼내서 분할 방식에따라 유휴 스레드에 작업을 할당한다. (Thread Assignment)
• 각 작업이 완료되면, 콜백 형태로 작업을 요청한 주체에게 결과를 알려준다. (Task Finished)

ThreadPool은 어렵고 복잡한 기술이라기보다는 그저 Thread를 잘 활용할 수 있게해주는 디자인패턴에 가깝다고 생각한다.

Thread Pool In Java

이제 자바에서는 어떻게 Thread Pool을 사용할 수 있는지 살펴본다.

자바는 5버전부터 자체적으로 Thread Pool을 지원하기 시작했다. java.util.concurrent 패키지에 ThreadPool과 관련된 클래스가 존재한다.

자바에서의 ThreadPool도 아래와 같이 동일하게 동작한다.

출처: https://www.baeldung.com/thread-pool-java-and-guava

스레드 풀의 실제 구현에서 코드를 분리한 상태로 유지하고 애플리케이션 전체에서 이러한 인터페이스를 사용해야 합니다.

자바는 ThreadPool과 관련된 코드를 비즈니스 로직과 분리시키기위해 Executor과 ExecutorService라는 인터페이스로 추상화시켰으며, Executors라는 유틸성 클래스를 만들어 편의 메서드를 제공한다.

스레드 풀 추상화 - Executor와 ExecutorService

자바는 손쉽게 스레드 풀을 제어할 수 있도록 Executor와 ExecutorService라는 인터페이스를 제공한다.

실제로 아래와 같이 손쉽게 스레드 풀을 생성할 수 있다.

ThreadPool 생성 예시 (스레드 100개)

ExecutorService threadPool = Executors.newFixedThreadPool(100);

생성한 스레드 풀에 Task (Runnable 혹은 Callable)을 제공하면 손쉽게 스레드 풀안의 스레드로 이를 실행시킬 수 있게된다.

Executor vs ExecutorService

자바에서는 ThreadPool과 관련된 코드를 Executor과 ExecutorService로 추상화시켰다. 그렇다면 이 둘의 차이점은 무엇일까?

🤔 Executor

public interface Executor {
    // Executes the given command at some time in the future. 
    // The command may execute in a new thread, in a pooled thread, or in the calling thread, at the discretion of the Executor implementation.
    void execute(Runnable command);
}

Executor는 넘겨받은 Runnable Task를 실행하는 메서드를 가진 간단한 인터페이스다.

인터페이스로 따로 빼둔 이유는 넘겨받은 Task를 스레드가 어떻게 실행할지, 스레드 스케줄링은 어떻게 할지등을 추상화시키기 위함이다.

쉽게 얘기하자면 기존엔 new Thread(new RunnableTask()).start()해야했던 작업을 아래와 같이 추상화 시킨것이다.

Executor executor = anExecutor;
executor.execute(new RunnableTask1()); // 새로운 Task를 어떻게 처리할지는 Executor 구현체에 따라 다르다.
executor.execute(new RunnableTask2());

자바는 스레드를 직접 구현하여 사용할 수 있도록 지원한다.

하지만.. 스레드를 직접 구현하여 사용하면, 코드 가독성이 너무 떨어지며, 코드만 보고는 정확히 어떻게 동작하는지 알기 쉽지않다.

그리하여 Thread Pool의 개념과 같이 자바는 Thread를 관리하고 부가 로직과 비즈니스 로직인 핵심 로직을 분리시키기위해 고수준의 인터페이스인 Executor, ExecutorService, Executors등을 만들었다.

즉, Thread를 생성하고 관리하는 부가로직을 핵심 로직으로부터 분리시킨 것이다.

이렇게 추상화시킴으로써 아래와같이 상황에 맞게 Executor 구현체를 만들어 Task를 처리할 수 있게 되었다.

1. 동기적으로 Task 처리 (Thread를 활용한 비동기를 사용하지 않음)

class DirectExecutor implements Executor {
    public void execute(Runnable r) {
        r.run();
    }
}

2. 매 Task마다 새로운 스레드를 생성하여 처리

class ThreadPerTaskExecutor implements Executor {
    public void execute(Runnable r) {
        new Thread(r).start();
    }
}

3. Task를 특정 스레드에 스케줄링할 때 컴포지트 혹은 프록시 패턴과 같이 사용하여 처리할 수 있다.

class SerialExecutor implements Executor {
    final Queue<Runnable> tasks = new ArrayDeque<Runnable>();
    final Executor executor;
    Runnable active;

    SerialExecutor(Executor executor) {
        this.executor = executor;
    }

    public synchronized void execute(final Runnable r) {
        tasks.offer(new Runnable() {
           try {
              r.run();
           } final {
              // 매 Task마다 끝나면 다음 Task 호출.
              scheduleNext();
           }
        });

        // 만약 현재 active(실행)되고있는 Task가 없다면 다음 Task 호출.
        if (active == null) {
           scheduleNext();
        }
    }

    // TaskQueue에서 다음 Task를 꺼내서 스레드에 스케줄링. (실행)
    protected synchronized void scheduleNext() {
        if ((active == tasks.poll() != null)) {
            executor.execute(active);
        }
    }
}

위와 같이 Executor라는 인터페이스를 분리시킴으로써 상황에 맞는 구현체를 만들거나 조합해서 다양하게 사용할 수 있다.

🤔 ExecutorService

public interface ExecutorService extends Executor {

    void shutdown();

    List<Runnable> shutdownNow();

    boolean isShutdown();

    boolean isTerminated();

    boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException;

    <T> Future<T> submit(Callable<T> task);

    <T> Future<T> submit(Runnable task, T result);

    Future<?> submit(Runnable task);

    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException;

    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                  long timeout, TimeUnit unit)
        throws InterruptedException;

    <T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws InterruptedException, ExecutionException;

    <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                    long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

ExecutorService는 Task를 관리하고 제어하는데 사용되는 Execute 인터페이스의 하위 인터페이스이다.

쉽게 말해 Execute보다 더 확장된 기능을 제공하기위한 인터페이스이다.

ThreadPool을 종료하는 메서드와 하나 이상의 비동기 작업을 추적하기 위한 Future를 반환하는 메서드를 제공한다.

• ExecutorService는 안전하게 종료할 수 있게 두 메서드를 제공한다.
  • shutdown(): 종료전에 요청된 Task (실행중인 Task + 대기중인 Task)는 모두 수행하도록하고 종료된다.
  • shutdownNow(): 대기 중인 Task가 시작되는 것을 멈추도록하고, 현재 실행중인 Task도 중지한다.
• ExecutorService는 Executor.execute(Runnable)를 확장하여 Task를 취소하거나 완료를 기다릴 때 사용되는 Future을 만들어 반환한다.
• ExecutorService는 invokeAny와 invokeAll을 통해 여러 개의 Task를 한번에 Submit되도록 벌크 연산을 지원한다.

🤔 Executor vs ExecutorService

• Executor: 주어진 Runnable을 실행만 한다.
• ExecutorService: Execute의 확장 -> Execute의 실행뿐만 아니라 시작하거나 종료하는등의 여러 기능을 확장.

💁‍♂️ 간단 예시 - Thread Pool을 활용하여 들어오는 요청을 처리하는 예시

NetworkService.java

class NetworkService implements Runnable {
    private final ServerSocket serverSocket;
    private final ExecutorService pool;

    public NetworkService(int port, int poolSize) throws IOException {
        serverSocket = new ServerSocket(port);
        pool = Executors.newFixedThreadPool(poolSize);
    }

    public void run {
        try {
           for (;;) {
              pool.execute(new Handler(serverSocket.accept()));
           }
        } catch (IOException ex) {
           pool.shutdown();
        }
    }
}

Handler.java

class Handler implements Runnable {
    private final Socket socket;
    
    Handler (Socket socket) {
        this.socket = socket;
    }

    public void run() {
       // read and service request on socket
    }
}

ThreadPool 사용 예시

자바에서 제공하는 FixedThreadPool을 이용한 간단한 스레드 풀 예시

Task.java

public class Task implements Runnable {

    private String name;

    public Task(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        try {
            for (int i = 0; i < 5; i++) {
                Date now = new Date();
                SimpleDateFormat dateFormat = new SimpleDateFormat("hh:mm:ss");

                if (i == 0) {
                    System.out.println(this.name + "  시작 - " + dateFormat.format(now));
                } else {
                    System.out.println(this.name + " 실행 - " + dateFormat.format(now));
                }
                Thread.sleep(1_000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(this.name + " Task 완료");
    }
}

ExampleMain.java

public class ExampleMain {

    public static void main(String[] args) {
        // given
        Runnable task1 = new Task("Task 1");
        Runnable task2 = new Task("Task 2");
        Runnable task3 = new Task("Task 3");
        Runnable task4 = new Task("Task 4");
        Runnable task5 = new Task("Task 5");

        ExecutorService threadPool = Executors.newFixedThreadPool(3); // ThreadPool의 Queue 최대 사이즈 3개 설정

        // when
        threadPool.execute(task1);
        threadPool.execute(task2);
        threadPool.execute(task3);
        threadPool.execute(task4);
        threadPool.execute(task5);

        // and
        threadPool.shutdown();
    }
}

실행 결과

• ThreadPool의 ThreadCore 최대 사이즈를 3개로 설정하여 5개의 Task를 요청한 예시이다.
  • 최대 사이즈가 3이기 때문에 Task4와 Task5는 Task1, 2, 3중 하나가 끝나 완료 상태가되서야 시작하는 것을 볼 수 있다.

ExecutorService

자바에서 ThreadPool을 사용하는 코드를 보면 대부분 ExecutorService를 구현한 클래스를 사용한다. 가장 중요하다고 볼 수 있다.

실제로 HikariCP의 일부 코드를 보면 ExecutorService를 구현한 ThreadPoolExecutor를 사용한다.

정확한 것은 아니다.. 추후에 HikariCP를 정리할 때 한번 더 알아볼 예정.

이번 챕터에선 ExecutorService의 대해서 정리하였다.

우선 어떻게 생성하는지, 어떤 구현체가 있는지 설명한다. 그리고 Task를 어떤 방식으로 요청하고 컨트롤하는지에 대해서 다룬다.

ExecutorService가 무엇인지에 대해선 위에 정리한 내용을 참고.

ExecutorService 구현체

자바에서 제공하는 ExecutorService의 구현체는 다양하다. 그리고 이 인터페이스를 구현한 객체는 ThreadPool 역할을 한다.

그런 의미에서 ExecutorService를 구현한 구현체 대부분은 ThreadPool이라고 봐도 될 것 같다.

ExecutorService의 구현체는 크게 두 개로 나뉜다.

• java.util.concurrent.ThreadPoolExecutor
• java.util.concurrent.ScheduledExecutorService

💁‍♂️ java.util.concurrent.ThreadPoolExecutor

// 직접 생성
int  corePoolSize  =    5;
int  maxPoolSize   =   10;
long keepAliveTime = 5000;

ExecutorService threadPoolExecutor =
        new ThreadPoolExecutor(
                corePoolSize,
                maxPoolSize,
                keepAliveTime,
                TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>()
        );

// Executors 이용하여 생성
ExecutorService executorService = Executors.newSingleThreadExecutor();
ExecutorService executorService = Executors.newFixedThreadPool(int nThreads);
ExecutorService executorService = Executors.newCachedThreadPool();

• 동작 과정
  • 주어진 Task (Callable 혹은 Runnable)을 내부적으로 동작하고 있는 ThreadPool을 이용해서 실행한다.
• 설정
  • Thread 개수
    • corePoolSize: Thread 개수 (Thread가 놀고있어도 계속 유지되는 개수)
    • maximumPoolSize: 최대 Thread 개수 (TaskQueue가 Full인 상태에서 corePoolSize보다 더 많은 스레드가 필요하면 Thread를 생성한다. 이때의 최대 생성 개수)
  • KeepAliveTime: Thread KeepAlive 시간
  • unit: KeepAliveTime 단위
  • workQueue: TaskQueue의 구현체 (ex. Runnable을 저장하는 BlockingQueue)
• Executors에서 제공하는 편의 메서드
  • Executors.newSingleThreadExecutor(): 단일 스레드 생성
    • 실패 시 새로 스레드를 생성하지 않는다 -> corePoolSize: 1, maximumPoolSize: 1
  • Executors.newFixedThreadPool(int nThreads): 고정 개수의 스레드 생성.
    • 모든 스레드가 작업중이면 TaskQueue에 작업을 적재한다. -> corePoolSize: n, maximumPoolSize: n
  • Executors.newCachedThreadPool(): 필요에 따라 새로운 스레드를 생성하며, 이전에 생성했던 스레드가 존재하면 재사용한다.
    • 디폴트로는 60초동안 스레드가 유지된다. -> corePoolSize: 0, maximumPoolSize: Integer.MAX_VALUE

설정에 대한 더 자세한 내용은 여기를 참고.

💁‍♂️ java.util.concurrent.ScheduledThreadPoolExecutor

public class ScheduledExecutorExample {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ScheduledExecutorService scheduledExecutorService =
                Executors.newScheduledThreadPool(5);

        ScheduledFuture<String> scheduledFuture =
                scheduledExecutorService.schedule(
                        () -> {
                            System.out.println("Executed!");
                            return "Callable Result";
                        },
                        5,
                        TimeUnit.SECONDS
                );
        
        System.out.println("실행 결과 (5초후) : " + scheduledFuture.get());
        scheduledExecutorService.shutdown();
    }
}
// 결과
Executed!
실행 결과 (5초후) : Callable Result

• 동작과정
  • 지정된 시간만큼 Delay후 Task를 실행하거나 주기적으로 실행한다.
  • ThreadPoolExecutor과 동일하다. 다만 ScheduledExecutorService인터페이스를 구현함으로써 schedule 메서드를 구현하고 있다.
    • public class ScheduledThreadPoolExecutor extends ThreadPoolExecutor implements ScheduledExecutorService {}
• 주요 메서드
  • schedule(Callable task, long delay, TimeUnit timeunit)
  • schedule(Runnable task, long delay, TimeUnit timeunit)
  • scheduleAtFixedRate(Runnable task, long initialDelay, long period, TimeUnit timeunit)
  • scheduleWithFixedDelay(Runnable task, long initialDelay, long period, TimeUnit timeunit)

더 자세한 내용은 여기를 확인.

꼭 Shutdown을 해줘야한다

모든 요청을 처리하고 더 이상 사용하지 않는다면 어떠한 ExecutorService든 shutdown()을 해야한다.

안그럼 JVM이 계속해서 ThreadPool의 Thread가 활성화된 상태에서 Task를 기다리기 때문에 프로그램이 종료되지 않는다.

종료시키는 메서드로는 shutdown(), shutdownNow(), awaitTermination()등이 있다.

invokeAny() vs invokeAll()

invoke가 붙은 메서드는 여러 개의 Task를 한번에 요청할 때 사용된다.

💁‍♂️ invokeAny()

invokeAny()는 Callable을 구현한 객체(Task)의 컬렉션을 매개변수로 받는다.

매 Callable의 Future를 반환하지 않고, 넘겨받은 컬렉션중 하나의 Callable에 대한 결과만을 반환한다.

<T> T invokeAny(Collection<? extends Callable<T>> tasks) throws ...

즉, 요청한 Task (Callable)중에서 하나라도 완료되면 해당 Task의 결과를 반환하고, 나머지 Task는 모두 Cancel한다.

If one of the tasks complete (or throws an exception), the rest of the Callable's are cancelled.

// invokeAny() 예시
public static void main(String[] args) throws ExecutionException, InterruptedException {
    ExecutorService executorService = Executors.newSingleThreadExecutor();

    Set<Callable<String>> callables = new HashSet<>();
    callables.add(() -> "Task 1 Completed");
    callables.add(() -> "Task 2 Completed");
    callables.add(() -> "Task 3 Completed");

    String result = executorService.invokeAny(callables);
    System.out.println(result); // Task 1 or Task 2 or Task 3

    executorService.shutdown();
}

// 결과
// Task 1 Completed 혹은 Task 2 Completed 혹은 Task 3 Completed

💁‍♂️ invokeAll()

invokeAll() 메서드는 invokeAny()와 다르게 모든 Task가 완료되어야 결과를 반환한다.

하나라도 완료되지 않았다면 holding된다.

결과는 List<Future>를 반환하며, 넘겨받은 Task (Callable)가 정상 처리되었던 예외가 발생하여 끝났던 완료된 것으로 본다.

즉, 동작중에 전달받은 Task들이 변경되거나 잘못되어도 결과를 보장하지 않는다.

잘못사용하면 요청한 Callable 결과를 기다리느라 Blocking이 되어 원치않게 성능이 저하될 수도 있다.

// invokeAll() 예시
public static void main(String[] args) throws InterruptedException, ExecutionException {
    ExecutorService executorService = Executors.newSingleThreadExecutor();

    Set<Callable<String>> callables = new HashSet<>();
    callables.add(() -> "Task 1 Completed");
    callables.add(() -> "Task 2 Completed");
    callables.add(() -> "Task 3 Completed");

    // 만약 Task들의 시간이 오래 걸린다면 여기서 Block되어 성능이 저하될 수도 있다.
    List<Future<String>> futures = executorService.invokeAll(callables);

    for (Future<String> future : futures) {
        System.out.println(future.get());
    }

    executorService.shutdown();
}
// 결과
Task 2 Completed
Task 3 Completed
Task 1 Completed

Task Cancel

ExecutorService에 요청한 Task (Runnable 혹은 Callable)은 Future.cancel()메서드를 호출하여 취소할 수 있다.

다만, Task가 아직 실행전일 때만 취소할 수 있다. 만약 실행중이라면 취소할 수 없다.

future.cancel();

마치며

예상보다 글이 길어졌다. 그래도 ThreadPool에 대한 개념을 잡을 수 있었고, 자바에선 어떻게 처리하는지 큰그림을 그릴 수 있었다.

누군가에겐 도움이 되는 글이 되기를~~~

간단한 ThreadPool을 직접 구현해보고싶다면 여기를 참고하면 된다.

필자는 직접 구현해보니 많은 도움이 되었다.

다음 글부터 비동기 처리에 대해서 정리한다. 아마 다음 글은 Future에 대한 글일 듯 싶다.

참고

• https://en.wikipedia.org/wiki/Thread_pool
• http://tutorials.jenkov.com/java-concurrency/thread-pools.html
• http://tutorials.jenkov.com/java-util-concurrent/executorservice.html
• https://www.javatpoint.com/java-thread-pool
• https://stackoverflow.com/questions/15052317/whats-the-difference-between-executor-and-executorservice
• https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Executor.html
• https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ExecutorService.html
• https://docs.oracle.com/javase/tutorial/essential/concurrency/executors.html