web-dev-qa-db-fra.com

Création simultanée d'un nombre dynamique de threads

Chaque fois que je dois créer un nombre variable de threads. Je le fais en créant un tableau de Threads et en créant plusieurs.

Mais, je ne comprends pas comment démarrer ce nombre n de threads se comportant comme un concept de threading multiple. Je veux qu’ils s’exécutent en parallèle.

S'il vous plaît guider si quoi faire dans ce sénario.

javamultithreadingparallel-processing
13
sowmya

Mais, je ne comprends pas comment démarrer ce nombre n de threads se comportant comme un concept multi-threading. Je veux qu'ils courent en parallèle.

Vous pouvez certainement créer un tableau de threads en utilisant une boucle:

 Thread[] threads = new Thread[NUM_JOBS_TO_CREATE];
 for (int i = 0; i < threads.length; i++) {
     threads[i] = new Thread(new Runnable() {
         public void run() {
             // some code to run in parallel
             // this could also be another class that implements Runnable
         }
     });
     threads[i].start();
 }

Cela entraînera les threads à s'exécuter en arrière-plan en parallèle. Vous pourrez ensuite les rejoindre plus tard pour les attendre avant de continuer.

// wait for the threads running in the background to finish
for (Thread thread : threads) {
    thread.join();
}

Mais au lieu de gérer les threads vous-même, je vous recommanderais d'utiliser le Java Executors intégré. Ils font tout cela pour vous, ils sont plus faciles à gérer. Un des avantages de cette méthode est qu’elle sépare les tâches des threads qui les exécutent. Vous pouvez par exemple démarrer 10 threads pour exécuter 1000 et 1000 tâches en parallèle.

Voici un exemple de code ExecutorService:

 // create a pool of threads, 10 max jobs will execute in parallel
 ExecutorService threadPool = Executors.newFixedThreadPool(10);
 // submit jobs to be executing by the pool
 for (int i = 0; i < NUM_JOBS_TO_CREATE; i++) {
    threadPool.submit(new Runnable() {
         public void run() {
             // some code to run in parallel
             // this could also be another class that implements Runnable
         }
     });
 }
 // once you've submitted your last job to the service it should be shut down
 threadPool.shutdown();
 // wait for the threads to finish if necessary
 threadPool.awaitTermination(Long.MAX_VALUE, TimeUnit.MILLISECONDS);

Pour plus d'informations, consultez le tutoriel Java sur les exécuteurs de threads .

36
Gray

Essayez très fort de ne pas créer de tableaux de threads et d’essayer de les gérer - cela entraînera bientôt un désordre épouvantable. Si vous avez besoin d'un pool de threads pour exécuter des tâches, vous avez besoin d'une file d'attente producteur-consommateur. Créez-en un et transmettez-le (ou l'instance d'objet threadpool qui le contient en tant que membre) aux threads à mesure que vous les créez. Les threads tournent en boucle, récupérant des tâches et les exécutant.

Le moyen le plus simple de procéder consiste à utiliser un service d’exécution décrit par @Gray, (+1).

Pour souligner que je n’insiste pas sur le sujet, n’essayez pas de micro-gérer les threads dans les tableaux, les listes ou les vecteurs, de les démarrer, de vérifier leur état dans une boucle 'patron/gestion', de les terminer/de les abandonner, de les détruire, etc. comme une Porsche 911 - après avoir dépensé une somme considérable d'argent/temps pour en obtenir une, vous obtiendrez quelque chose qui semble fonctionner correctement et qui se brisera soudainement pour vous faire basculer dans un arbre.

Utilisez un thread dédié pour les travaux bloqués pendant de longues périodes et un pool de threads pour ceux qui peuvent être effectués de manière intensive et rapide.

3
Martin James

Psuedocode de base:

create x threads, store them in an array or list;
for each thread in the list/array
   call start() on the thread object;
2
Hunter McMillen

Dans une classe devant être multithread, je place en haut de la classe:

private static final ExecutorService executor = Executors.newCachedThreadPool();

& En Java 8+, j'utilise une expression lamda partout où j'ai besoin de quelque chose pour exécuter un nouveau fil:

executor.submit(() -> {
        myOtherClass.myFunction(doSomething);
});

Avec newCachedThreadPool, Java gérera le nombre total de threads en fonction du nombre de cœurs de processeur sur le système et les arrêtera automatiquement après une période d’inactivité (60 secondes par défaut).

0
Stuart Cardall