Tutoriel Java Threading Type Question

Question

Je suis assez naïf en ce qui concerne le monde du Java Threading et de la concurrence. J'essaie actuellement d'apprendre. J'ai fait un exemple simple pour essayer de comprendre comment fonctionne la concurrence.

Voici mon code:

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

public class ThreadedService { 

    private ExecutorService exec; 

    /** 
    * @param delegate 
    * @param poolSize 
    */ 
    public ThreadedService(int poolSize) { 
     if (poolSize < 1) { 
      this.exec = Executors.newCachedThreadPool(); 
     } else { 
      this.exec = Executors.newFixedThreadPool(poolSize); 
     } 
    } 

    public void add(final String str) { 
     exec.execute(new Runnable() { 
      public void run() { 
       System.out.println(str); 
      } 

     }); 

    } 

    public static void main(String args[]) { 
     ThreadedService t = new ThreadedService(25); 
     for (int i = 0; i < 100; i++) { 
      t.add("ADD: " + i); 
     } 
    } 

} 

Que dois-je faire pour rendre l'impression de code les numéros 0-99 dans un ordre séquentiel?

Answer 1

Thread pools sont généralement utilisés pour les opérations qui ne nécessitent pas synchronization ou sont hautement parallel.

L'impression séquentielle des numéros 0 à 99 n'est pas un problème simultané et nécessite la synchronisation des unités d'exécution pour éviter leur impression dans le désordre.

Je recommande de jeter un oeil à Java concurrency lesson pour avoir une idée de la concurrence en Java.

Answer 2

La solution la plus simple à votre problème est d'utiliser une taille ThreadPool de 1. Cependant, ce n'est pas vraiment le genre de problème que l'on pourrait utiliser pour résoudre les problèmes.

Pour développer, si vous créez votre exécuteur avec:

this.exec = Executors.newSingleThreadExecutor(); 

alors vos fils seront tous programmés et exécutés dans l'ordre où ils ont été soumis à l'exécution. Il y a quelques scénarios où c'est une chose logique à faire, mais dans la plupart des cas, les Threads sont le mauvais outil à utiliser pour résoudre ce problème.

Ce genre de chose est logique lorsque vous devez exécuter la tâche dans un thread différent - peut-être que cela prend du temps à s'exécuter et que vous ne voulez pas bloquer un thread graphique - mais vous ne le faites pas Il est nécessaire ou non que les tâches soumises soient exécutées en même temps.

Answer 3

L'idée des threads n'est pas de faire les choses de manière séquentielle.

Vous aurez besoin d'un état partagé à coordonner. Dans l'exemple, l'ajout de champs d'instance à votre classe externe fonctionnera dans cet exemple. Supprimez le paramètre d'ajouter. Ajouter un objet de verrouillage et un compteur. Saisir le verrou, incrémenter imprimer le numéro, incrémenter le numéro, libérer le numéro.

Answer 4

Le problème n'est par définition pas adapté aux threads. Les threads sont exécutés indépendamment et il n'y a pas vraiment de moyen de prédire quel thread est exécuté en premier.

Si vous voulez changer votre code à exécuter de manière séquentielle, changer ajouter à:

public void add(final String str) { 
    System.out.println(str); 
} 

Vous n'utilisez threads (pas votre propre au moins) et tout se passe de manière séquentielle.