HOME > java > concurrency

Java - ScheduledThreadPoolExecutor 사용 방법

By JS | 02 Nov 2019

만약 어떤 작업을 일정 시간 지연 후에 수행하거나, 일정 시간 간격으로 주기적으로 실행해야 한다면, ScheduledThreadPoolExecutor를 고려해보는 것이 좋습니다.

ScheduledThreadPoolExecutor 다음 4개의 메소드들을 제공합니다.

  • schedule(Runnable command, long delay, TimeUnit unit) : 작업을 일정 시간 뒤에 한번 실행합니다.
  • schedule(Callable command, long delay, TimeUnit unit) : 작업을 일정 시간 뒤에 한번 실행하고, 그 결과를 리턴합니다.
  • scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) : 작업을 일정 시간 간격으로 반복적으로 실행시킵니다.
  • scheduleWithFixedDelay(Runnable command, long initialDelay, long period, TimeUnit unit) : 작업이 완료되면 일정 시간 뒤에 다시 실행시킵니다. scheduleAtFixedRate()와 다른 점은 작업 종료시점이 기준이라는 것입니다.

schedule(Runnable)

schedule()은 일정 시간(delay) 뒤에 Job을 실행시키는 메소드입니다.

schedule()에 전달되는 인자는 다음과 같습니다.

  • Runnable : 리턴 값이 없는 Runnable을 인자로 받습니다.
  • delay : 지연 시킬 시간입니다.
  • TimeUnit : 시간 단위입니다.
package concurrent;

import java.time.LocalTime;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ScheduledThreadPoolExecutorExample1 {

    public static void main(String[] args) {

        ScheduledExecutorService executor = Executors.newScheduledThreadPool(2);
        Runnable runnable = () -> System.out.println("Runnable task : " + LocalTime.now());
        int delay = 3;

        // Job을 스케쥴링합니다.
        System.out.println("Scheduled task : " + LocalTime.now() );
        executor.schedule(runnable, delay, TimeUnit.SECONDS);
    }
}

결과

Scheduled task : 22:58:43.006
Runnable task : 22:58:46.007

schedule(Callable)

schedule()은 일정 시간 뒤에 Job을 실행시키는 메소드입니다.

schedule()에 전달되는 인자는 다음과 같습니다.

  • Callable : T를 리턴하는 Callable 인자로 받습니다.
  • delay : 지연 시킬 시간입니다.
  • TimeUnit : 시간 단위입니다.

schedule()은 ScheduledFuture를 리턴하며 Job이 완료되면 ScheduledFuture.get()으로 리턴값을 얻을 수 있습니다.

package concurrent;

import java.time.LocalTime;
import java.util.concurrent.*;

public class ScheduledThreadPoolExecutorExample2 {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        ScheduledExecutorService executor = Executors.newScheduledThreadPool(2);
        Callable<String> callable =  () -> "Callable task : " + LocalTime.now();
        int delay = 3;

        // Job을 스케쥴링합니다.
        System.out.println("Scheduled task : " + LocalTime.now() );
        ScheduledFuture<String> future =
            executor.schedule(callable, delay, TimeUnit.SECONDS);

        // 결과가 리턴될 때 까지 기다립니다.
        String result = future.get();
        System.out.println(result);
    }
}

결과

Scheduled task : 23:00:00.025
Callable task : 23:00:03.027

scheduleAtFixedRate()

scheduleAtFixedRate()는 작업을 일정 시간 간격으로 실행시키는 메소드입니다.

scheduleAtFixedRate()에 전달되는 인자는 다음과 같습니다.

  • Runnable : 리턴 값이 없는 Runnable을 인자로 받습니다.
  • initialDelay : Job이 처음 실행될 때 기다리는 시간입니다.
  • delay : Job이 실행되는 시간 간격입니다.
  • TimeUnit : 시간 단위입니다.

다음 예제의 결과를 보시면 Job이 실행된 후(완료되는 시간과 무관하게), 일정 delay 뒤에 다시 Job을 실행시키는 것을 볼 수 있습니다.

package concurrent;

import java.time.LocalTime;
import java.util.concurrent.*;

public class ScheduledThreadPoolExecutorExample3 {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        ScheduledExecutorService executor = Executors.newScheduledThreadPool(2);
        Runnable runnable = () -> {
            System.out.println("++ Repeat task : " + LocalTime.now());
            sleepSec(3);
            System.out.println("-- Repeat task : " + LocalTime.now());
        };
        int initialDelay = 2;
        int delay = 3;

        // Job을 스케쥴링합니다.
        System.out.println("Scheduled task : " + LocalTime.now() );
        executor.scheduleAtFixedRate(
            runnable, initialDelay, delay, TimeUnit.SECONDS);
    }

    private static void sleepSec(int sec) {
        try {
            TimeUnit.SECONDS.sleep(sec);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

결과

Scheduled task : 23:01:48.967
++ Repeat task : 23:01:50.969
-- Repeat task : 23:01:53.969
++ Repeat task : 23:01:53.970
-- Repeat task : 23:01:56.970
++ Repeat task : 23:01:56.971
-- Repeat task : 23:01:59.971
++ Repeat task : 23:01:59.971
-- Repeat task : 23:02:02.972
++ Repeat task : 23:02:02.972
-- Repeat task : 23:02:05.972
++ Repeat task : 23:02:05.973
-- Repeat task : 23:02:08.973
....

scheduleWithFixedDelay()

scheduleAtFixedRate()는 Job이 완료된 후, 일정 시간 뒤에 다시 Job을 실행시키는 메소드입니다.

scheduleWithFixedDelay()에 전달되는 인자는 다음과 같습니다.

  • Runnable : 리턴 값이 없는 Runnable을 인자로 받습니다.
  • initialDelay : Job이 처음 실행될 때 기다리는 시간입니다.
  • delay : Job이 완료된 후 다음 Job이 실행될 때까지 기다리는 시간입니다.
  • TimeUnit : 시간 단위입니다.

다음 예제의 결과를 보시면 Job이 끝난 후, delay만큼 기다린 후 다음 Job을 실행시키는 것을 볼 수 있습니다.

package concurrent;

import java.time.LocalTime;
import java.util.concurrent.*;

public class ScheduledThreadPoolExecutorExample4 {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        ScheduledExecutorService executor = Executors.newScheduledThreadPool(2);
        Runnable runnable = () -> {
            System.out.println("++ Repeat task : " + LocalTime.now());
            sleepSec(3);
            System.out.println("-- Repeat task : " + LocalTime.now());
        };
        int initialDelay = 2;
        int delay = 3;

        // Job을 스케쥴링합니다.
        System.out.println("Scheduled task : " + LocalTime.now() );
        executor.scheduleWithFixedDelay(
            runnable, initialDelay , delay, TimeUnit.SECONDS);
    }

    private static void sleepSec(int sec) {
        try {
            TimeUnit.SECONDS.sleep(sec);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

결과

Scheduled task : 23:03:29.282
++ Repeat task : 23:03:31.284
-- Repeat task : 23:03:34.285
++ Repeat task : 23:03:37.285
-- Repeat task : 23:03:40.286
++ Repeat task : 23:03:43.286
-- Repeat task : 23:03:46.286
++ Repeat task : 23:03:49.287
-- Repeat task : 23:03:52.287
++ Repeat task : 23:03:55.288
-- Repeat task : 23:03:58.288
++ Repeat task : 23:04:01.288
-- Repeat task : 23:04:04.289
....