Comment faire pour exécuter des tâches dans ExecutorService séquentiellement?

J'ai trois fils qui sont reliés, c'est à dire le deuxième thread s'exécute après le premier meurt.

C'est le code que j'ai:

public class Main {
    public static void main(String args[]) throws Exception {
        final Thread thrdA = new Thread(() -> System.out.println("Message 1"));
        final Thread thrdB = new Thread(() -> System.out.println("Message 2"));
        final Thread thrdC = new Thread(() -> System.out.println("Message 3"));

        thrdA.start();
        thrdA.join();
        thrdB.start();
        thrdB.join();
        thrdC.start();
        thrdC.join();

    }
}

Comment mettre en œuvre cette fonctionnalité à l'aide ExecutorService au lieu de trois thread objets?

OriginalL'auteur Raees Sharif-Aamir | 2015-08-16

  1. 21

    Si ce que vous voulez/besoin pour exécuter un groupe d'emplois l'un après l'autre, mais dans un seul thread différent que l'application principale fil, puis utiliser Exécuteurs#newSingleThreadExecutor.

    ExecutorService es = Executors.newSingleThreadExecutor();
es.submit(() -> System.out.println("Message 1"));
es.submit(() -> System.out.println("Message 2"));
es.submit(() -> System.out.println("Message 3"));
es.shutdown();
    Si je fais cela, puis les messages ne s'est pas exécuté dans l'ordre, je démarre les threads, par exemple, la sortie doit être "Message 1" puis "Message 2" puis le Message "3". Ils s'exécutent dans un ordre aléatoire par exemple "Message 2", "Message " 3", "Message 1". Ce que j'essaie de dire, c'est comment aurais-je exécuter un exécutable pour chaque message dans un executorservice telle que la sortie est dans l'ordre croissant "Message 1" puis "Message 2" puis le Message "3" et non pas un ordre aléatoire comme "Message 2", "Message " 3", "Message 1".
    Je suppose que mon éditer des réponses ce que vous voulez ou avez besoin.
    Merci, je serais upvote si je pouvais
    Je suis perplexe. Votre question porte sur plusieurs threads, mais il semble que vous ne voulez faire qu'une seule chose à la fois.
    c'est le droit. OP seulement besoin d'un seul thread à exécuter plusieurs tâches, l'une aftwr l'autre.

    OriginalL'auteur Luiggi Mendoza

  2. 4

    Vous pouvez contrôler l'exécution séquentielle de threads à l'aide de SingleThread ExecutorService avec l'avenir.méthode get ().

    DummyTask Classe

    import java.util.concurrent.Callable;

public class DummyTask implements Callable<Integer>
{

int taskId;

public DummyTask(int taskId) {
    this.taskId = taskId;
}

@Override
public Integer call() throws Exception
{
    System.out.println("excuting task... Task Id: " + taskId);
    return taskId;
}

}

    SequentialExecution Classe

    package com.amit.executorservice;

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

public class SequentialExecution 
{
public static void main(String[] args) throws InterruptedException, ExecutionException {

    DummyTask task1 = new DummyTask(1);
    DummyTask task2 = new DummyTask(2);
    DummyTask task3 = new DummyTask(3);
    Future<Integer> result = null;
    ExecutorService executor = Executors.newSingleThreadExecutor();

    result = executor.submit( task1 );
    //future.get() Waits for the task to complete, and then retrieves its result.
    result.get();

    result = executor.submit( task2 );
    //future.get() Waits for the task to complete, and then retrieves its result.
    result.get();

    result = executor.submit( task3 );
    //future.get() Waits for the task to complete, and then retrieves its result.
    result.get();

    executor.shutdown();

}
}

    Sortie

    excuting task... Task Id: 1
excuting task... Task Id: 2
excuting task... Task Id: 3

    La sortie sera toujours de même et toutes les tâches seront exécutés dans l'ordre.

    La clé ici est Executors.newSingleThreadExecutor(), pas l'utilisation de Future.

    OriginalL'auteur Amit Tamrakar

  3. 1

    Si vous utilisez déjà un pool de threads dans votre application, vous pouvez la réutiliser par le biais de zéro filetée proxy série d'exécuteur testamentaire, sans créer de spécial mono-thread pool de threads.
    Une mise en œuvre est décrite dans le javadoc de la section de l'Exécuteur testamentaire de l'interface, un autre, optimisation de la mise en œuvre, à mon dépôt Github CodeSamples.

    OriginalL'auteur Alexei Kaigorodov