Lesson 9 - Java Multithreading - Runnable, Callable, Future, Executor

In the previous lesson, Multithreading in Java - Barrier, CountDownLatch, we got familiar with the barrier. In today's tutorial, we're going to take a closer look at Runnable, Callable, and Future interfaces. We'll introduce their methods and differences. In the second part of the article we'll focus on the Executor interface. There will be no implementations in this lesson.

Runnable, Callable, and Future

These three interfaces are the basis of multithreading in Java.

Runnable

We've already encountered the Runnable interface at the beginning when we were learning to create threads. One way to create a thread was through its constructor with a Runnable parameter. This interface contains only one method:

@FunctionalInterface
public interface Runnable {
  public void run();
}

The body of the run() method is executed on the thread and the thread terminates when it's done. This interface is perfect for some simple tasks, but it has one important drawback: if the thread was calculating something, there's no easy way to tell the "parent" that the calculation has finished (or failed). We'd have to use, for example, a semaphore or a barrier. The next interface tries to fix this problem.

Callable

This interface is generic, which means that we have to specify the data type in angle brackets when implementing it. This data type represents the result that the method will return once the "calculation" is completed:

...End of the preview...
Continue further