Discussion :

[supcomingenieur]

Bonjour,
j'ai une classe "ExecuteSNMP" qui permet de générer un répertoire contenant 6 fichiers textes.
j'ai une deuxième classe "ConcatFile" qui prend ces 6 fichiers, les concatène en un seul et charge ce dernier dans une Table SQL.
mes deux classes heritent des Thread.
et j'ai une troisième classe "TEST" qui instancie mes deux classes précédentes. TEST n'Herite pas de Thread.
Jusqu'à présent pour empêcher que la concaténation ne soit lancée avant la générations des 6 fichiers j'uitlise la commande wait(3000) de cette manière:

Code :

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

1
2
3
4
5
6
7
8
 
      ExecuteSnmp execute=new ExecuteSnmp(this, oids, files, dir,sh);
      execute.start();
 
     syncronized(this){this.wait(3000);}
 
      ConcatFile c=new ConcatFile (this,dir,scripts,sh);
      c.start();

tout allait très bien jusqu'à ce que j'ai voulu la classe "TEST" dans une autre classe. J'ai remarqué alors que la génération et la concaténation du fichier pouvait ce chevaucher.

j'ai alors remplacer l'instruction wait(3000) par ce bout de code. Mais ça ne résout pas mon problème.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 while (condition==false)
      {
          if (dir.list().length==6) // dir est le répertoire contenant les 6 fichiers
          {
              condition=true;
          }
          else if  (dir.list().length<6)
          {
              condition=false;
          }
      }

comment résoudre ce problème sans passer par une synchronisation du répertoire (je essayé de le faire mais je n'y arrive pas c'est extremement difficile je trouve).

merci

[adiGuba]

Salut,



Pourquoi tu utilises des threads ?


a++

[supcomingenieur]

par ce que la générations des 6 fichiers doit se faire plus ou moin parallèlement.

[adiGuba]

Heu... Tu dis toi même que "ConcatFile" doit être exécuté seulement lorsque les 6 fichiers seront générés. Donc le parallélisme ne sert à rien !


a++

[supcomingenieur]

je voulais dire que la classe "ExecuteSNMP" doit être un thread car c'est elle la classe resonsable de la générations des fichiers. Mais pour la classe "ConcatFile" tu as raison ce n'est pas la peine qu'elle herite de Thread.

Comment je fais sinon?

[thelvin]

Les 6 fichiers doivent, j'imagine, être crées avec 6 threads ou quelque chose comme ça, pour être crées en parallèle.

Si ExecuteSNMP est un Thread, ça ne fait qu'un seul thread pour les 6 fichiers.
=> Ça ne marche pas.
=> ExecuteSNMP ne doit pas être un Thread
=> ExecuteSNMP doit être un bout de code parfaitement normal, qui consiste à appeler plusieurs Thread, et attendre qu'ils se finissent tous, avec join() sur chacun d'eux.

[supcomingenieur]

C'est vrai et j'ai déja modifié ce détail.
maintenant j'ai la configuration suivante:
classe ExceuteSNMP --> lances 6 Threads pour céer 6 fichier (ExceuteSNMP classe normale)
classe ConcatFile--> concatène les 6 fichier (elle aussi classe normale).
classe Test qui instancie ExceuteSNMP et ConcatFile.

maintenant comment creer ce décalage entre ExcexuteSNMP et concatFile.
moi j'utilise toujours ce code (c'est le corps de la classe Tesr)

Code :

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

1
2
3
4
5
6
7
8
9
 
ExecuteSnmp execute=new ExecuteSnmp(this, oids, files, dir,sh);
execute.commencer();
 
      synchronized(this){this.wait(5000);}
 
      // mettre à jour la table
       ConcatFile c=new ConcatFile (this,dir,scripts,sh);
       c.commencer();

ça marche uniquement si j'exécute le fichier test.java mais si je veux instancier la classe test dans un autre fichier j'ai un problème entre la création et la lecture.

merci

[thelvin]

Normalement si tu les appelles l'un après l'autre, ils se feront l'un après l'autre.
Tu te rappelles, Programmation, mettre les lignes dans le bon ordre, tout ça.

Bien sûr, celui qui crée les threads doit bien penser à attendre qu'ils se finissent, avant de terminer sa propre exécution.

[supcomingenieur]

En fait après l'instantiation et le démarrage de chaque thread, j'ai ajouté join() pour chacun d'entre eux, et maintenant plsu besoin d'utiliser la méthode wait, ça se fait automatiquement. Donc affaire résolue.

J'ai pourtant un autre problème. J'ai maintenant trois classes chacune doit remplire une table SQL indépendemment des autres, je voudrais instancier ces classes de manières périodique (la première chaque 10mn, la deuxième chaque 15 mn et la dernière chaque 20mn).
Puisque ces trois classes sont indépendentes, je voudrais les exécuter parallèlement. J'ai fait ce code mais je sais pas comment ajouter cette touche de périodicité:

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
public class RunServer {
    
    static TargetRouter target;
    
    public RunServer(TargetRouter target) throws IOException, Exception
    {
        this.target=target;
        this.run();
    }
    
    public void run() throws IOException, Exception
    {
        while (true)
        {
      
            new Thread(){public void run(){try {
                    new Chassis_Monitoring(target); 1ere classe
                 
                } catch (IOException ex) {
                    Logger.getLogger(RunServer.class.getName()).log(Level.SEVERE, null, ex);
                } catch (Exception ex) {
                    Logger.getLogger(RunServer.class.getName()).log(Level.SEVERE, null, ex);
                }
}}.start();
            new Thread(){public void run(){try {
                    new Total_Traffic_History(target); 2eme classe
                 
                } catch (IOException ex) {
                    Logger.getLogger(RunServer.class.getName()).log(Level.SEVERE, null, ex);
                } catch (Exception ex) {
                    Logger.getLogger(RunServer.class.getName()).log(Level.SEVERE, null, ex);
                }
}}.start();
            
            new Thread(){public void run(){try {
                    new Throughput_History(target);  3iemme classe
              
                } catch (IOException ex) {
                    Logger.getLogger(RunServer.class.getName()).log(Level.SEVERE, null, ex);
                } catch (Exception ex) {
                    Logger.getLogger(RunServer.class.getName()).log(Level.SEVERE, null, ex);
                }
}}.start();
Thread.sleep(5000);
        }
        
    }
    
    public static void main(String[] args) throws Exception {
        RunServer run=new RunServer(new TargetRouter ("10.53.3.150", "INTERNET@orange", "OrangeTunisie", "ge-1/1/9.1074"));
    }
}

merci pour vos réponses ça m'a beaucoup aidé.

[adiGuba]

En fait après l'instantiation et le démarrage de chaque thread, j'ai ajouté join() pour chacun d'entre eux, et maintenant plsu besoin d'utiliser la méthode wait, ça se fait automatiquement. Donc affaire résolue.

Donc tu lances des threads mais tu attends qu'ils finissent avant de passer à autre chose...

c'est du séquentiel et tu n'a pas besoin de thread pour cela !


a++

[bouye]

Donc tu lances des threads mais tu attends qu'ils finissent avant de passer à autre chose...

c'est du séquentiel et tu n'a pas besoin de thread pour cela !


a++

J'vois pas pourquoi y peut pas créer ses 6 fichiers en parallèle et attendre ensuite pour finir sa concaténation. Ça sera de toute manière plus rapide que de tout faire séquentiellement, ça sera pas 1/6 du temps séquentiel certes mais ça peut quand même apporter pas mal suivant la grosseur des écritures.
C'est un peu comme quand on a découvert qu'on pouvait compiler nos plus gros projets C++ avec make -j 8 ; ça a éclairé notre journée, ce jour-la.

java.util.Timer ou java.util.concurrent.ScheduledThreadPoolExecutor pour des trucs périodiques.

[adiGuba]

J'vois pas pourquoi y peut pas créer ses 6 fichiers en parallèle et attendre ensuite pour finir sa concaténation.

Oui... mais du coup la concatenation n'a pas besoin d'être en parallèle.


Là on a un thread qui s'occupe de générer les 6 fichiers (ExecuteSnmp) et un thread qui s'occupe de les concaténer (ConcatFile).
Et ce dernier thread doit attendre la fin du premier pour s'exécuter...

Donc clairement cela ne sert pas à grand chose !!!

Je veux dire à quoi ca sert de lancer 2 threads si le second doit attendre que le premier se termine pour faire son boulot... Cela revient à faire du séquentielle tout en s'emmerdant avec les problèmes liés au parallèle... sans les bénéfices !!!




Maintenant c'est vrai que concernant la première tâche (ExecuteSnmp), il y a moyen d'optimiser cela en découpant la tâche en plusieurs sous-tâches en parallèle via 6 threads (voir mieux en utilisant un ExecutorService se basant sur le nombre de processus disponible) (quoique pour des tâches d'I/O c'est pas forcément mieux - enfin c'est à tester).

Mais ExecuteSnmp et ConcatFile n'ont rien de parallèle entre-elle...




a++

[Dantidot]

Salut,
Bon je ne prendrai pas part au débat. Je me contente d'apporter une réponse.

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
public class RunServer {
 
    static TargetRouter target;
 
 
    private static int time0  = 600000;
    private static int time1   = 900000;
    private static int time1bis = 1200000;
 
    public RunServer(TargetRouter target) throws IOException, Exception
    {
        this.target=target;
        this.run();
    }
 
    public void run() throws IOException, Exception
    {    
            new Thread(){public void run(){
                while (true) {
                    try {
                       new Chassis_Monitoring(target); 1ere classe
 
                    } catch (IOException ex)                                                                             {                                                                                                                                                               Logger.getLogger(RunServer.class.getName()).log(Level.SEVERE, null, ex);
                      } catch (Exception ex) {
                    Logger.getLogger(RunServer.class.getName()).log(Level.SEVERE, null, ex);
                      }
           Thread.sleep(time0);
 
            }
 
        }
          }.start();
            new Thread(){public void run(){try {
              while (true) {
                    new Total_Traffic_History(target); 2eme classe
 
                } catch (IOException ex) {
                    Logger.getLogger(RunServer.class.getName()).log(Level.SEVERE, null, ex);
                } catch (Exception ex) {
                    Logger.getLogger(RunServer.class.getName()).log(Level.SEVERE, null, ex);
                }
     Thread.sleep (time1);
}
}
 
}.start();
 
            new Thread(){public void run(){
 
 
 
                 while (true) {
                   try {
                      new Throughput_History(target);  3iemme classe
 
                   } catch (IOException ex) {
                      Logger.getLogger(RunServer.class.getName()).log(Level.SEVERE, null, ex);
                   } catch (Exception ex) {
                      Logger.getLogger(RunServer.class.getName()).log(Level.SEVERE, null, ex);
                   }
Thread.sleep(time1bis);
}}.start();
}
 
 
 
    public static void main(String[] args) throws Exception {
        RunServer run=new RunServer(new TargetRouter ("10.53.3.150", "INTERNET@orange", "OrangeTunisie", "ge-1/1/9.1074"));
    }
}

[thelvin]

C'est souvent bien d'apporter des réponses... Mais c'est encore mieux quand elles ont un rapport avec la question.

De toute façon la réponse a déjà été donnée : join(). Pas compliqué -_-°.