Java ExecutorService에 대한 가이드

1. 개요

ExecutorService 는 비동기 모드에서 태스크 실행을 단순화하는 JDK에서 제공하는 프레임 워크입니다. 일반적으로 ExecutorService 는 작업을 할당하기위한 스레드 풀과 API를 자동으로 제공합니다.

2. ExecutorService 인스턴스화

2.1. Executors 클래스 의 팩토리 메서드

ExecutorService 를 만드는 가장 쉬운 방법 은 Executors 클래스 의 팩토리 메서드 중 하나를 사용하는 것입니다 .

예를 들어 다음 코드 줄은 10 개의 스레드가있는 스레드 풀을 만듭니다.

ExecutorService executor = Executors.newFixedThreadPool(10);

특정 사용 사례를 충족하는 사전 정의 된 ExecutorService 를 만드는 몇 가지 다른 팩토리 메서드가 있습니다 . 요구 사항에 가장 적합한 방법을 찾으려면 Oracle의 공식 문서를 참조하십시오.

2.2. ExecutorService 직접 생성

ExecutorService 는 인터페이스 이기 때문에 모든 구현의 인스턴스를 사용할 수 있습니다. java.util.concurrent 패키지 에서 선택할 수있는 여러 가지 구현이 있거나 직접 만들 수 있습니다.

예를 들어, ThreadPoolExecutor 클래스에는 실행기 서비스와 내부 풀을 구성하는 데 사용할 수있는 몇 가지 생성자가 있습니다.

ExecutorService executorService = new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue());

위의 코드는 팩토리 메소드 newSingleThreadExecutor () 의 소스 코드와 매우 유사하다는 것을 알 수 있습니다 . 대부분의 경우 자세한 수동 구성은 필요하지 않습니다.

3. ExecutorService에 태스크 할당

ExecutorService 는 실행 가능호출 가능 태스크를 실행할 수 있습니다 . 이 기사에서 간단하게 유지하기 위해 두 가지 기본 작업이 사용됩니다. 여기에서는 익명의 내부 클래스 대신 람다식이 사용됩니다.

Runnable runnableTask = () -> { try { TimeUnit.MILLISECONDS.sleep(300); } catch (InterruptedException e) { e.printStackTrace(); } }; Callable callableTask = () -> { TimeUnit.MILLISECONDS.sleep(300); return "Task's execution"; }; List
    
      callableTasks = new ArrayList(); callableTasks.add(callableTask); callableTasks.add(callableTask); callableTasks.add(callableTask);
    

Executor 인터페이스 에서 상속 된 execute ()submit () , invokeAny (), invokeAll ()을 포함하여 여러 메서드를 사용 하여 ExecutorService에 태스크를 할당 할 수 있습니다 .

실행 () 방법은 무효, 그것은 가능성 작업의 실행 결과를 얻기 위해 또는 작업의 상태를 확인합니다 (실행 중이거나 실행)을 제공하지 않습니다.

executorService.execute(runnableTask);

submit () Callable 또는 Runnable 태스크를 ExecutorService에 제출하고 Future 유형의 결과를 반환합니다.

Future future = executorService.submit(callableTask);

invokeAny () ExecutorService 에 작업 모음을 할당하여 각작업을실행하고 하나의 작업을 성공적으로 실행 한 결과를 반환합니다 (성공적인 실행이있는 경우) .

String result = executorService.invokeAny(callableTasks);

invokeAll () ExecutorService 에 작업 모음을 할당하여 각 작업을 실행하고 Future 유형의 객체 목록 형식으로 모든 작업 실행 결과를 반환합니다 .

List
    
      futures = executorService.invokeAll(callableTasks);
    

이제 더 진행하기 전에 ExecutorService를 종료하고 Future 반환 유형을 처리 하는 두 가지 사항에 대해 더 논의해야합니다 .

4. ExecutorService 종료

일반적으로 ExecutorService 는 처리 할 작업이 없을 때 자동으로 삭제되지 않습니다. 그것은 살아 있고 새로운 작업이 수행 될 때까지 기다릴 것입니다.

어떤 경우에는 이것은 매우 유용합니다. 예를 들어 앱이 불규칙적으로 나타나는 작업을 처리해야하거나 컴파일 타임에 이러한 작업의 양을 알 수없는 경우입니다.

반면에 앱은 끝에 도달 할 수 있지만 대기중인 ExecutorService 로 인해 JVM이 계속 실행 되므로 중지되지 않습니다 .

ExecutorService 를 올바르게 종료하기 위해 shutdown ()shutdownNow () API가 있습니다.

종료 () 메소드는 즉시 파괴가 발생하지 않습니다 ExecutorService를합니다. 그것은 것 ExecutorService를의 새 작업을 수신을 중단하고 실행중인 모든 스레드가 현재 작업을 완료 한 후 종료합니다.

executorService.shutdown();

shutdownNow의 () 메소드의 시도는 파괴 ExecutorService입니다을 즉시, 그러나 실행중인 모든 스레드가 동시에 중단되는 것은 아닙니다. 이 메서드는 처리 대기중인 작업 목록을 반환합니다. 이러한 작업으로 수행 할 작업을 결정하는 것은 개발자의 몫입니다.

List notExecutedTasks = executorService.shutDownNow();

ExecutorService 를 종료하는 한 가지 좋은 방법 (Oracle에서도 권장)은 awaitTermination () 메서드 와 결합 된 두 메서드를 모두 사용하는 것입니다 . 이 접근 방식을 사용하면 ExecutorService 는 먼저 새 작업 수행을 중지 한 다음 모든 작업이 완료 될 때까지 지정된 시간까지 기다립니다. 해당 시간이 만료되면 실행이 즉시 중지됩니다.

executorService.shutdown(); try { if (!executorService.awaitTermination(800, TimeUnit.MILLISECONDS)) { executorService.shutdownNow(); } } catch (InterruptedException e) { executorService.shutdownNow(); }

5. 미래 인터페이스

The submit() and invokeAll() methods return an object or a collection of objects of type Future, which allows us to get the result of a task's execution or to check the task's status (is it running or executed).

The Future interface provides a special blocking method get() which returns an actual result of the Callable task's execution or null in the case of Runnable task. Calling the get() method while the task is still running will cause execution to block until the task is properly executed and the result is available.

Future future = executorService.submit(callableTask); String result = null; try { result = future.get(); } catch (InterruptedException | ExecutionException e) { e.printStackTrace(); }

With very long blocking caused by the get() method, an application's performance can degrade. If the resulting data is not crucial, it is possible to avoid such a problem by using timeouts:

String result = future.get(200, TimeUnit.MILLISECONDS);

If the execution period is longer than specified (in this case 200 milliseconds), a TimeoutException will be thrown.

The isDone() method can be used to check if the assigned task is already processed or not.

The Future interface also provides for the cancellation of task execution with the cancel() method, and to check the cancellation with isCancelled() method:

boolean canceled = future.cancel(true); boolean isCancelled = future.isCancelled();

6. The ScheduledExecutorService Interface

The ScheduledExecutorService runs tasks after some predefined delay and/or periodically. Once again, the best way to instantiate a ScheduledExecutorService is to use the factory methods of the Executors class.

For this section, a ScheduledExecutorService with one thread will be used:

ScheduledExecutorService executorService = Executors .newSingleThreadScheduledExecutor();

To schedule a single task's execution after a fixed delay, us the scheduled() method of the ScheduledExecutorService. There are two scheduled() methods that allow you to execute Runnable or Callable tasks:

Future resultFuture = executorService.schedule(callableTask, 1, TimeUnit.SECONDS);

The scheduleAtFixedRate() method lets execute a task periodically after a fixed delay. The code above delays for one second before executing callableTask.

The following block of code will execute a task after an initial delay of 100 milliseconds, and after that, it will execute the same task every 450 milliseconds. If the processor needs more time to execute an assigned task than the period parameter of the scheduleAtFixedRate() method, the ScheduledExecutorService will wait until the current task is completed before starting the next:

Future resultFuture = service .scheduleAtFixedRate(runnableTask, 100, 450, TimeUnit.MILLISECONDS);

If it is necessary to have a fixed length delay between iterations of the task, scheduleWithFixedDelay() should be used. For example, the following code will guarantee a 150-millisecond pause between the end of the current execution and the start of another one.

service.scheduleWithFixedDelay(task, 100, 150, TimeUnit.MILLISECONDS);

According to the scheduleAtFixedRate() and scheduleWithFixedDelay() method contracts, period execution of the task will end at the termination of the ExecutorService or if an exception is thrown during task execution.

7. ExecutorService vs. Fork/Join

After the release of Java 7, many developers decided that the ExecutorService framework should be replaced by the fork/join framework. This is not always the right decision, however. Despite the simplicity of usage and the frequent performance gains associated with fork/join, there is also a reduction in the amount of developer control over concurrent execution.

ExecutorService gives the developer the ability to control the number of generated threads and the granularity of tasks which should be executed by separate threads. The best use case for ExecutorService is the processing of independent tasks, such as transactions or requests according to the scheme “one thread for one task.”

In contrast, according to Oracle's documentation, fork/join was designed to speed up work which can be broken into smaller pieces recursively.

8. Conclusion

Even despite the relative simplicity of ExecutorService, there are a few common pitfalls. Let's summarize them:

Keeping an unused ExecutorService alive: There is a detailed explanation in section 4 of this article about how to shut down an ExecutorService;

Wrong thread-pool capacity while using fixed length thread-pool: It is very important to determine how many threads the application will need to execute tasks efficiently. A thread-pool that is too large will cause unnecessary overhead just to create threads which mostly will be in the waiting mode. Too few can make an application seem unresponsive because of long waiting periods for tasks in the queue;

Calling a Future‘s get() method after task cancellation: An attempt to get the result of an already canceled task will trigger a CancellationException.

Unexpectedly-long blocking with Future‘s get() method: Timeouts should be used to avoid unexpected waits.

이 기사의 코드는 GitHub 저장소에서 사용할 수 있습니다.