Exécuteur testamentaire de service en java--> comment faire pour convertir un seul thread de code pour utiliser exécuteur testamentaire

Pardonnez-moi si la question a l'air bête - je suis juste de commencer à utiliser l'Exécuteur testamentaire.

J'ai déjà une application java qui utilise des threads de cette manière, essentiellement autonome fils sont utilisés--

private Thread spawnThread( )
    {

        Thread t = new Thread()
        {
            String taskSnap = task.toString();
            public void run()
            {
                try
                {
                    println( task.run( null ) );
                }catch( InterruptedException e )
                {
                    println( "ITC - " + taskSnap + " interrupted " );
                }
            }
        };
        return t;
    }

Comme vous pouvez le voir ci-dessus, la fonction renvoie un nouveau thread.

Maintenant dans la fonction main() du programme, un nouveau thread est créé de cette manière--

    taskThread = spawnThread();

    taskThread.start();

Ce que je veux faire, c'est créer un exécuteur testamentaire (service fixe nombre de threads)-->, et puis remettre la création d'un nouveau thread/exécution de la tâche par le nouveau thread pour que l'exécuteur testamentaire.

Que je suis très nouveau à l'Exécuteur testamentaire, ce que je souhaite savoir, c'est, comment puis-je changer le code ci-dessus de sorte qu'au lieu d'un nouveau thread séparé en cours de formation, un nouveau thread est créé à la place dans le pool de threads. Je ne vois aucune commande pour créer un thread (dans le pool de threads)--> main de la tâche ci-dessus à ce thread (et non pas à un seul thread, comme ci-dessus).

S'il vous plaît laissez-moi savoir comment résoudre ce problème.

Envelopper le "run" de votre Thread de l'interface Runnable. Créer un exécuteur testamentaire et de l'offre de l'Exécutable. Jetez un oeil à travers les Exécuteur sentier pour plus d'info

OriginalL'auteur Arvind | 2013-02-17

Dans votre main, vous pouvez écrire quelque chose comme ceci:

ExecutorService executor = Executors.newFixedThreadPool(nThreads);
executor.submit(new Runnable() {
    String taskSnap = task.toString();
    public void run() {
            try {
                println(task.run(null));
            } catch( InterruptedException e) {
                println("ITC - " + taskSnap + " interrupted ");
            }
    }
});

La méthode submit va exécuter l'Exécutable sur un des fils à l'intérieur de l'exécuteur de service.

Remarque: N'oubliez pas de l'arrêt de l'exécuteur de service lorsque vous n'en avez plus besoin ou qu'il empêchera votre programme de sortie de.

OriginalL'auteur assylias

Faire vos recherches avant de demander. L'idée est de créer une classe qui implémente Runnable et de l'exécuter à l'aide de l'exécuteur de service.

Exemple: Java De La Concurrence (Multithreading) - Tutoriel

Mise en œuvre de l'ouvrier (qui implémente Runnable):

package de.vogella.concurrency.threadpools;

/** * MyRunnable will count the sum of the number from 1 to the parameter * countUntil and then write the result to the console. * <p> * MyRunnable is the task which will be performed * * @author Lars Vogel * */

public class MyRunnable implements Runnable {
  private final long countUntil;

  MyRunnable(long countUntil) {
    this.countUntil = countUntil;
  }

  @Override
  public void run() {
    long sum = 0;
    for (long i = 1; i < countUntil; i++) {
      sum += i;
    }
    System.out.println(sum);
  }
}

Comment utiliser exécuteur de service pour exécuter le déclencheur le thread de travail.

package de.vogella.concurrency.threadpools;

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

public class Main {
  private static final int NTHREDS = 10;

  public static void main(String[] args) {
    //You can also use Executors.newSingleThreadExecutor() if you just need 1 thread
    ExecutorService executor = Executors.newFixedThreadPool(NTHREDS);
    for (int i = 0; i < 500; i++) {
      Runnable worker = new MyRunnable(10000000L + i);
      executor.execute(worker);
    }
    //This will make the executor accept no new threads
    //and finish all existing threads in the queue.
    executor.shutdown();
    //Wait until all threads are finish
    //while (!executor.isTerminated()) {
    //}
    //System.out.println("Finished all threads");
    //All the threads might not be finished at this point of time. Thread endtime purely depends on the time taken by the processing logic inside your thread.
  }
}

Mais vous ne devriez pas être occupé attente...
Bien sûr, c'est juste un exemple de code pour comprendre un thread de l'anatomie. Dans le code réel, vous ne serez pas attendre inutilement.
Ok, mais je crains DONC un exemple de code sera souvent utilisé comme "parce que ça marche"...
J'ai acheter que. A commenté le code.

OriginalL'auteur zengr

Vous voulez dire quelque chose comme cela?

class Parallel {
    private ExecutorService pool = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

    public void shutdown() {
        pool.shutdown();
    }

    public void foo() {
        pool.submit(new Runnable() {
            @Override
            public void run() {
                //put your code here
            }
        });
    }
}

OriginalL'auteur Axel

Vous devez vous connecter pour publier un commentaire.