Interface Runnable VS Callable en Java

1. L’interface Runnable en Java
2. L’exemple d’interface Runnable en Java
3. L’interface Callable en Java
4. L’exemple d’interface Callable en Java
5. Interface Runnable VS Callable en Java

Ce tutoriel présente la différence entre les interfaces Runnable et Callable avec des exemples en Java.

L’interface Runnable en Java

Runnable est une interface utilisée pour créer et exécuter des threads en Java. Il n’a qu’une seule méthode abstraite run() et est également connu sous le nom d’interface Functional.

Vous pouvez voir la signature de l’interface Runnable et sa méthode SAM ci-dessous.

@FunctionalInterface public interface Runnable

void run() // Single Abstract Method

L’exemple d’interface Runnable en Java

Chaque classe qui souhaite créer et exécuter un thread doit implémenter soit une interface Runnable, soit étendre la classe Thread.

L’interface Runnable fournit une méthode run() qui doit être surchargée dans la classe de base. Cette méthode s’exécute implicitement par la méthode start(). Voir l’exemple ci-dessous.

public class SimpleTesting implements Runnable {
  public static void main(String[] args) {
    new Thread(new SimpleTesting()).start();
  }
  @Override
  public void run() {
    System.out.println("Running a thread");
  }
}

Production :

Running a thread

L’interface Callable en Java

Le Callable est une interface et est similaire à l’interface Runnable. Il contient également une seule méthode abstraite, call().

Cette interface est conçue pour les classes dont les instances sont potentiellement exécutées par un autre thread. La signature de l’interface et de la méthode Callable est ci-dessous :

La classe Executors contient des méthodes utilitaires pour convertir en classes Callable à partir d’autres formes courantes.

@FunctionalInterface public interface Callable<V>

V call() throws Exception

L’exemple d’interface Callable en Java

Nous avons implémenté l’interface Callable et remplacé sa méthode call(). Nous pouvons obtenir n’importe quel objet à la méthode call().

Voir l’exemple ci-dessous.

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class SimpleTesting implements Callable<Integer> {
  public static void main(String[] args) throws InterruptedException, ExecutionException {
    ExecutorService executorService = Executors.newSingleThreadExecutor();
    SimpleTesting st = new SimpleTesting();
    Future<Integer> future = executorService.submit(st);
    int result = future.get().intValue();
    System.out.println("product " + result);
  }

  @Override
  public Integer call() throws Exception {
    int product = 23 * 12;
    return product;
  }
}

Production :

product 276

Interface Runnable VS Callable en Java

Le tableau suivant contient quelques points pour comprendre l’interface Runnable et Callable de Java.