Puis-je utiliser des threads Callable sans ExecutorService?

Puis-je utiliser Appelable fils sans ExecutorService? Nous pouvons utiliser des instances de l'Exécutable et des sous-classes de Fil sans ExecutorService et ce code fonctionne normalement. Mais ce code fonctionne toujours:

public class Application2 {

    public static class WordLengthCallable implements Callable {
        public static int count = 0;
        private final int numberOfThread = count++;

        public Integer call() throws InterruptedException {
            int sum = 0;
            for (int i = 0; i < 100000; i++) {
               sum += i;
            }
            System.out.println(numberOfThread);
            return numberOfThread;
       }
   }
   public static void main(String[] args) throws InterruptedException {
       WordLengthCallable wordLengthCallable1 = new WordLengthCallable();
       WordLengthCallable wordLengthCallable2 = new WordLengthCallable();
       WordLengthCallable wordLengthCallable3 = new WordLengthCallable();
       WordLengthCallable wordLengthCallable4 = new WordLengthCallable();
       wordLengthCallable1.call();
       wordLengthCallable2.call();
       wordLengthCallable3.call();
       wordLengthCallable4.call();
       try {
           Thread.sleep(1000);
       } catch (InterruptedException e) {
          e.printStackTrace();
      }
      System.exit(0);
  }
}

Avec ExecutorService le code fonctionne avec quelques fils. Où sont mes erreurs?

source d'informationauteur user3233853

  1. 20

    Tout interfaces sont souvent créés avec un but de cas d'utilisation, ils ne sont jamais limités à être utilisé de cette façon.

    Donné un Runnable vous pouvez le soumettre à un ExecutorServiceou passer au constructeur de Thread ou vous pouvez invoquer son run() méthode directement comme vous pouvez vous prévaloir d'une quelconque interface méthode sans le multi-threading impliqués. Et il y a plus de cas d'utilisation, par exemple AWT EventQueue.invokeLater(Runnable) donc, ne jamais attendre la liste complète.

    Donné un Callablevous avez les mêmes options, il est donc important de souligner que, contrairement à votre question suggère, en invoquant call() directement ne comporte pas de multi-threading. Il a juste exécute la méthode, comme toutes les invocation de méthode.

    Car il n'y a pas de constructeur Thread(Callable) à l'aide d'un Callable avec un Thread sans ExecutorService nécessite un peu plus de code:

    FutureTask<ResultType> futureTask = new FutureTask<>(callable);
Thread t=new Thread(futureTask);
t.start();
//…
ResultType result = futureTask.get(); //will wait for the async completion