Executor führen nicht alle Threads aus.

Question

Ich bin neu in Java und versuche das hier. Ich habe eine Methode, die ich parallel ausführen möchte. Ich wünsche mir, dass 10 Threads die Methode aufrufen und ihre Ergebnisse erhalten.

Ich verwende dafür Callable und Executors. Ich erstelle den Thread-Pool wie folgt:

 ExecutorService executor = Executors.newFixedThreadPool(10);

und wenn ich das mache:

 executor.invokeAll(taskList);

wird nur ein Thread aus dem Pool genommen. Und ich erhalte nur folgendes gedruckt:

Der aktuelle Thread lautet pool-1-thread-1

Aber ich wünsche mir, dass es 10 ähnliche println-Anweisungen gibt.

Hier ist der vollständige Code:

import java.util.concurrent.Callable;
import java.util.List;
import java.util.ArrayList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.Future;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutorCompletionService;

public class Parallel
{
    public static void main(String args[])
    {
        Learning l = new Learning();
        l.message = "1st Object";
        l.testThread();
    }
}

//diese Klasse handhabt die Threads
class Learning
{

    public String message;

    public void setMessage(String message)
    {
        this.message = message;
    }

    //enthält den Code, in dem
    public void testThread()
    {

       //Erstelle ein Callable für jede Methode
       Callable callable1 = new Callable()
       {
          @Override
          public String call() throws Exception
          {
             System.out.println("Der aktuelle Thread ist " + Thread.currentThread().getName());
             return method1();
             // return null;
          }
       };

       //Füge der Liste hinzu
       List> taskList = new ArrayList>();
       taskList.add(callable1);

       //erstelle einen Pool-Executor mit 10 Threads
       ExecutorService executor = Executors.newFixedThreadPool(10);

       try
       {
         List> futureList = executor.invokeAll(taskList);

       }
       catch (InterruptedException ie)
       {
       }
    }

    //füge deinen Code hier ein!
    private String method1()
    {
        return Thread.currentThread().getName();
    }
}

Fehtl mir etwas hier?

Answer 1

Ihr ExecutorService hat die Kapazität, 10 Threads auszuführen. Aber Sie haben nur einen Thread eingereicht. Ändern Sie die testThread Methode wie folgt.

// enthält den Code, wo
public void testThread() {
    // zur Liste hinzufügen
    List> taskList = new ArrayList>();
    Callable callable1=null;
    for (int i = 0; i < 10; i++) {
        // erstellen Sie einen Callable für jede Methode
        callable1 = new Callable() {
            @Override
            public String call() throws Exception {
                System.out.println("Der aktuelle Thread ist " + Thread.currentThread().getName());
                return method1();
                // return null;
            }
        };
        taskList.add(callable1);
    }

    // erstellen Sie einen Pool Executor mit 10 Threads
    ExecutorService executor = Executors.newFixedThreadPool(10);

    try {
        List> futureList = executor.invokeAll(taskList);

    } catch (InterruptedException ie) {
    }
}

Answer 2

Die taskList hat nur einen callable darin. Fügen Sie mehr callables zur Liste hinzu und warten Sie eine Weile in method1(), damit alle 10 Threads im Pool beschäftigt werden.

import java.util.concurrent.Callable;
import java.util.List;
import java.util.ArrayList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.Future;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutorCompletionService;

public class Parallel
{
    public static void main(String args[])
    {
        Learning l = new Learning();
        l.setMessage("1. Objekt");
        l.testThread();
    }
}

//diese Klasse behandelt Threads
class Learning
{

    public String message;

    public void setMessage(String message)
    {
        this.message = message;
    }

    //enthält den Code, in dem
    public void testThread()
    {

       //eine Callable für jede Methode erstellen
       Callable callable1[] = new Callable[10];

       for(int i=0;i<10;++i){
       callable1[i] =  new Callable(){
          @Override
          public String call() throws Exception
          {
             System.out.println("Der aktuelle Thread ist " + Thread.currentThread().getName());
             return method1();
             // return null;
          }
       };
   }

   //zu einer Liste hinzufügen
   List> taskList = new ArrayList>();

   for(int i=0;i<10;++i){
       taskList.add(callable1[i]);
   }

   //einen Pool-Executor mit 10 Threads erstellen
   ExecutorService executor = Executors.newFixedThreadPool(10);

   try
   {
     List> futureList = executor.invokeAll(taskList);
     executor.shutdown();

   }
   catch (InterruptedException ie)
   {
   }
}

//Geben Sie hier Ihren Code ein!
private String method1()
{
    return Thread.currentThread().getName();
}
}

Answer 3

Immer wenn Sie unsicher sind, lesen Sie das Javadoc nach. Wenn Sie die Methode invokeAll lesen, finden Sie folgendes

Führt die gegebenen Aufgaben aus und gibt eine Liste von Futures zurück, die ihren Status und ihre Ergebnisse enthalten, wenn alle abgeschlossen sind.

Wenn Sie also eine Aufgabe angeben, wird eine Aufgabe abgeschlossen. Wenn Sie möchten, dass 10 Aufgaben abgeschlossen werden, müssen Sie 10 Aufgaben angeben. Auch wenn keine weiteren Aufgaben mehr eingereicht werden sollen, können Sie aufrufen

executor.shutDown()

Diese Methode schließt den Dienst, nachdem sichergestellt wurde, dass alle eingereichten Aufgaben abgeschlossen sind.

Answer 4

Das Problem besteht darin, dass der Executor einen Aufruf oder einen ausführbaren Thread aufruft. In Ihrer Aufgabenliste haben Sie nur eine Instanz des Typs Aufruf hinzugefügt und diese Aufgabenliste dem Executor übergeben. Daher wird der Executor nur eine Aufgabe ausführen. Fügen Sie weitere Aufrufe zur Aufgabenliste hinzu und übergeben Sie sie dann dem Executor.