[Thread] Runnable and Callable in Java

Java 초기부터 멀티스레딩은 언어의 주요 측면이었다. 

 

Runnable 은 다중 스레드 작업을 나타내기 위해 제공되는 핵심 인터페이스이고,

Callable 은 Java 1.5에 추가된Runnable의 개선된 버전이다.

 

두 인터페이스 모두 여러 스레드에서 실행할 수 있는 작업을 나타내도록 설계되었다. 

하지만, Runnable은 Thread클래스 또는ExecutorService 를 사용하여 실행할 수 있는 반면 Callable 은 후자를 사용해서만 실행할 수 있다.

 

그럼 차이점을 자세히 살펴보자.

 

Runnable

💡반환 값

Runnable 인터페이스 는 기능적 인터페이스이며 매개변수를 허용하지 않고 값을 반환하지 않는 단일 run() 메서드가 있다. 스레드 실행의 결과를 찾지 않는 상황에 적합하다.

 

💡실행 방식

1) Thread 클래스

package e.thread;

public class RunnableSample implements Runnable{
    @Override
    public void run() {
        System.out.println("This is RunnableSample's run() method.");
    }
}

 

package e.thread;

public class RunThreads {
    public static void main(String[] args) {
        RunThreads threads = new RunThreads();
        threads.runBasic();
    }

    public void runBasic() {
        //Runnable 인터페이스를 구현한 RunnableSample 클래스를 쓰레드로 바로 시작할 수는 없다.
        //따라서, 이와 같이 Thread 클래스의 생성자에 해당 객체를 추가하여 시작해주어야만 한다.
        RunnableSample runnable = new RunnableSample();
        new Thread(runnable).start();

    }
}

먼저 run()이라는 메소드는 쓰레드가 수행되는 우리가 구현하는 메소드를 말하고, start()라는 메소드는 쓰레드를 시작하는 메소드다. 

 

위의 코드에서처럼 Runnable 인터페이스를 구현한 경우에는 Thread 클래스의 생성자에 해당 객체를 추가하여 시작해

주면 된다. 

 

Runnable 인터페이스를 구현하는 경우와, Thread 클래스를 확장하는 경우에 대한 비교 이야기는 아래의 게시글로 이동해서 보자.

 

https://mong-dev.tistory.com/17

[Thread] Thread를 생성하는 방법 - Runnable 인터페이스와 Thread 클래스의 차이

 

 

2) ExecutorService 

public interface Runnable {
    public void run();
}

 

public class EventLoggingTask implements  Runnable{
    private Logger logger
      = LoggerFactory.getLogger(EventLoggingTask.class);

    @Override
    public void run() {
        logger.info("Message");
    }
}

public void executeTask() {
    // Executors의 팩토리 메서드를 호출해 싱글쓰레드인 Executor를 생성함
    executorService = Executors.new SingleThreadExecutor();
    // executor에 Task 인스턴스를 제출(submit)해서 실행을 요청함
    Future future = executorService.submit(new EventLoggingTask());
    // 종료
    executorService.shutdown();
}

이 예에서 스레드는 큐에서 메시지를 읽고 로그 파일에 기록하는데, 작업에서 반환된 값은 없다. 마지막의 executeTask() 메소드에서 보듯이 ExecutorService를 사용하여 시작할 수 있다. 이 경우 Future 객체는 어떤 값도 보유하지 않는다.

 

 

Callable

💡반환 값

Callable 인터페이스는 제네릭 값 V를 반환하는 단일 call() 메서드를 포함 하는 일반 인터페이스이다.

 

💡실행 방식

1) Only ExecutorService 

public interface Callable<V> {
    V call() throws Exception;
}

 

숫자의 계승을 계산하는 방법을 call()에 구현하였다. 메서드 선언부에 throws로 예외처리가 되어있는데, 이부분은 바로 다음 단락에서 살펴볼 예정이니 실행 방식만 먼저 보도록 한다.

public class FactorialTask implements Callable<Integer> {
    int number;

    // standard constructors

    public Integer call() throws InvalidParamaterException {
        int fact = 1;
        // ...
        for(int count = number; count > 1; count--) {
            fact = fact * count;
        }

        return fact;
    }
}

@Test
public void whenTaskSubmitted_ThenFutureResultObtained(){
    FactorialTask task = new FactorialTask(5);
    Future<Integer> future = executorService.submit(task);
 
    assertEquals(120, future.get().intValue());
}

 

앞서 말했듯이, 여기서 중요한 포인트는 call() 메서드 의 결과는 Future 객체 내에서 반환이 된다는 것이다.

 

 

💡예외처리

Runnable의 경우에는 메서드 선언시, "throws" 절이 지정되어 있지 않기 때문에 추가로 검사된 예외를 전파할 방법이 없는데 반해, Callable의 call() 메서드에는 "throws Exception" 절이 포함되어 있으므로 checked 예외를 더 쉽게 전파할 수 있다.

 

✅call()은 run()처럼 오버라이드 시 구현부의 로직을 개별 쓰레드를 통해 실행시킨다는 점은 같지만, 반환값이 있어야하고 반환에 실패하면 예외를 던지게 할 수 있다. 발생 가능한 예외를 미리 선언하면 외부에서 호출 시 예외 처리를 강제할 수 있기 때문에 안정성의 측면에서 큰 장점이다.

 

 

다음 코드를 보자.

 

public class FactorialTask implements Callable<Integer> {
    // ...
    public Integer call() throws InvalidParamaterException {

        if(number < 0) {
            throw new InvalidParamaterException("Number should be positive");
        }
    // ...
    }
}

@Test(expected = ExecutionException.class)
public void whenException_ThenCallableThrowsIt() {
 
    FactorialCallableTask task = new FactorialCallableTask(-5);
    Future<Integer> future = executorService.submit(task);
    Integer result = future.get().intValue();
}

 

ExecutorService를 사용하여 Callable을 실행하는 경우, Future.get()메서드를 호출하여 확인할 수 있는 Future객체에 예외가 수집된다. 이렇게 하면 원래 예외를 래핑 하는 ExecutionException이 발생한다.

 

위의 테스트에서 유효하지 않은 숫자를 전달할 때, ExecutionException이 발생한다. 이 예외 객체에 대해 getCause() 메서드를 호출 하여 원래 확인된 예외를 가져올 수 있다.

 

Future 클래스의 get() 메서드를 호출하지 않으면 call ( )메서드에서 throw된 예외가 다시 보고되지 않고, 작업은 여전히 ​​완료된 것으로 표시된다. 아래 코드는 get()메서드를 호출하지 않은 경우이다.

@Test
public void whenException_ThenCallableDoesntThrowsItIfGetIsNotCalled(){
    FactorialCallableTask task = new FactorialCallableTask(-5);
    Future<Integer> future = executorService.submit(task);
 
    assertEquals(false, future.isDone());
}

위의 테스트는 FactorialCallableTask에 대한 매개변수의 음수 값에 대한 예외를 throw하더라도 성공적으로 통과한다.

 

 

 

정리

	Runnable	Callable
도입	JDK 1.0	JDK 1.5
패키지	java.lang	java.util.concurrent
보유 메서드	run()	call()
메서드 반환값	없음	있음
메서드 예외 선언	불가능	가능
실행 방법	Thread 또는 ExecutionService	ExecutionService

 

📗Reference

- 자바의 신
- https://www.baeldung.com/java-runnable-callable
- https://jvnlee.tistory.com/8