Discussion :

[vLemaistre]

Bonjour,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
public void run()
    {
        try {
 
            // .......................
 
        writerFileHTML(rH.responseRequest(), "responseHtml" + (i + 1) + ".html");
 
        result += formater.format(date) + "," + url + post + "," + product.get(i) + "," + rH.getTimeRequest();
        // if (result != null && existFile == false)
        csvOutput.write(formater.format(date));
        csvOutput.write(url + post);
        csvOutput.write(product.get(i));
        csvOutput.write(String.valueOf(rH.getTimeRequest()));
        csvOutput.endRecord();
 
        System.out.println(result);
 
    }
    catch (Exception e) {
        // System.out.println(e.toString());
 
    }
}

Exécution du Thread de la méthode run

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
public static void main(String[] args) throws Exception
{
        // ........................
 
 
                tabSimu = new Simulateur[nombreDeThread];
        csvOutput = new CsvWriter(new FileWriter(outputFile, true), ',');
        for (i = 0; i < nombreDeThread; i++)
        {
 
            beginDate = formater.parse(arrayListeDate.get(i));
            Date currentDate = formater.parse(arrayListeDate.get(i + 1));
 
            duree = (currentDate.getTime() - beginDate.getTime());
 
            // TODO Auto-generated catch block
 
            // System.out.print(duree);
            tabSimu[i] = new Simulateur();
            tabSimu[i].start();
            Thread.sleep(duree);
        }
// ..........................
}

Lorsque des requêtes s'exécute en même temps, il y a les mêmes requêtes qui s'exécute alors qu'il doit exécuter une autre requête, je pense que dans mon tableau de Thread chaque Thread entre en collision.

Pouvez-vous m'aider svp? Merci!!!

Cordialement.

[thelvin]

Hello,

oui c'est un peu normal que des threads entrent en collision quand on s'arrange pas pour qu'ils ne le fassent pas, puisque le principe des threads c'est qu'ils s'exécutent en même temps et pas l'un après l'autre.

Mais on va pas deviner ce que c'est tes histoires de requêtes, là. L'important c'est comment tes threads choisissent le prochain travail qu'ils font. S'ils font ça tous en même temps ils vont choisir le même travail, entre autres. Normal.

[vLemaistre]

Hello,

oui c'est un peu normal que des threads entrent en collision quand on s'arrange pas pour qu'ils ne le fassent pas, puisque le principe des threads c'est qu'ils s'exécutent en même temps et pas l'un après l'autre.

Mais on va pas deviner ce que c'est tes histoires de requêtes, là. L'important c'est comment tes threads choisissent le prochain travail qu'ils font. S'ils font ça tous en même temps ils vont choisir le même travail, entre autres. Normal.

D'accord, merci mais ça ne me dit pas comment régler ce problème. Quelle classe utiliser et quelles méthodes ou une librairie?

[joel.drigo]

Salut,

Ta description n'est pas assez précise pour qu'on comprenne exactement ce que ton programme doit faire. A priori, de ce que je comprends, tu as un ensemble de requêtes que tu veux faire traiter par plusieurs threads.

1. Solution à la mano : avoir une liste de requêtes, et gérer les accès concurrents sur cette liste. A la base, il y a le mot clef synchronized qui permet de créer un bloc, ou une méthode, qui ne pourra être exécuté par plusieurs threads différents en même temps. Si le code s'occupe de prendre une requête dans la liste de requête (en l'enlevant de cette liste), aucun thread ne pourra pas traiter une requête traitée par un autre, en pensant à la problématique d'éviter qu'un thread ne tourne à vide (en consommant du cpu pour rien) quand il n'y a pas de requête en attente de traitement
   Il y a également des classes qui implémentent directement ce principe (voir les BlockingQueue par exemple), en gérant l'attente des threads.
2. Solution plus simple, utiliser un service d'exécution qui a un pool de threads : voir Executors.newFixedThreadPool(nbThreads). Ou selon le cas, d'autres type de services d'exécution (il y en a par exemple qui crée un thread par tâche, et qui a un intérêt lorsqu'il y a beaucoup de requêtes, mais qu'elles sont courtes en terme d'exécution (sinon, on risque une augmentation importante du nombre de threads concurrents). En plus ces classes facilite la récupération de résultat différé.
3. Voir aussi les capacités de la classe Stream en terme de parallélisation.

[vLemaistre]

Merci pour ta réponse, je suis en train d'essayer la 2ème solution avec Executors

[vLemaistre]

Salut,

Ta description n'est pas assez précise pour qu'on comprenne exactement ce que ton programme doit faire. A priori, de ce que je comprends, tu as un ensemble de requêtes que tu veux faire traiter par plusieurs threads.

1. Solution à la mano : avoir une liste de requêtes, et gérer les accès concurrents sur cette liste. A la base, il y a le mot clef synchronized qui permet de créer un bloc, ou une méthode, qui ne pourra être exécuté par plusieurs threads différents en même temps. Si le code s'occupe de prendre une requête dans la liste de requête (en l'enlevant de cette liste), aucun thread ne pourra pas traiter une requête traitée par un autre, en pensant à la problématique d'éviter qu'un thread ne tourne à vide (en consommant du cpu pour rien) quand il n'y a pas de requête en attente de traitement
   Il y a également des classes qui implémentent directement ce principe (voir les BlockingQueue par exemple), en gérant l'attente des threads.
2. Solution plus simple, utiliser un service d'exécution qui a un pool de threads : voir Executors.newFixedThreadPool(nbThreads). Ou selon le cas, d'autres type de services d'exécution (il y en a par exemple qui crée un thread par tâche, et qui a un intérêt lorsqu'il y a beaucoup de requêtes, mais qu'elles sont courtes en terme d'exécution (sinon, on risque une augmentation importante du nombre de threads concurrents). En plus ces classes facilite la récupération de résultat différé.
3. Voir aussi les capacités de la classe Stream en terme de parallélisation.

J'ai utilisé Executors.newFixedThreadPool(nbThreads), le problème c'est que j'ai + de 1000 requêtes http à exécuter et un maximum de 10 requêtes / sec
selon des durées, je ne sais pas combien utilisé de Thread et ou mettre une tempo?

[joel.drigo]

un maximum de 10 requêtes / sec

Tu veux dire que ton serveur ne te permet pas plus de 10 requêtes par seconde et il te bloque si tu dépasses ?