Soucis de chronologie d exécution

Version imprimable

06/01/2017, 12h37
raphael75015

Soucis de chronologie d exécution

Bonjour toutes et tous

je vous adresse mes meilleurs voeux pour cette nouvelle année.

Je viens vers vous car je rencontre un petit problème que mes faibles compétences en java ne me permettent pas de résoudre.

je vous l'expose brièvement.

mon application doit exécuter toute les 2 heures une vérification de différents fichiers et de leur contenu.

Ces contrôles sont au nombre de 6.

principe :

mon ihm dispose d'un bouton à partir duquel
1/ j'appelle une classe progress.java
2/ j'incrémente l'heure de début de la prochaine campagne de vérification pour reboucler.

dans ma classe progress
je lance successivement 6 classes lesquelles constituent chacun de mes 6 contrôles.
elle intègre également une fenêtre dans laquelle une barre de progression évolue au grès de l'évolution des 6 contrôles

mon problème réside dans le fait que la classe progress rende la main dès le début de son exécution induisant des problèmes de freeze de de ma barre d'évolution lorsque la classe principale reprend le relais ( test de l heure de la prochaine scrutation ).

je cherche donc la solution qui me permettrait d'attendre la fin de l'exécution de la class "progress" sachant que sa durée d'exécution reste aléatoire.

J'espère avoir été suffisamment clair dans mes explications.

il est possible voire probable que le principe de fonctionnement ne soit pas le meilleur et je reste à votre écoute pour parfaire et mes compétences et mon outil.

Cordialement
06/01/2017, 14h02
joel.drigo

Salut,

Il nous faudrait voir le code sans ça difficile d'émettre un avis. Tu utilises un SwngWorker pour faire ton processus avec la barre de progression ?
06/01/2017, 14h02
Sebajuste

Bonjour, et mes meilleurs voeux pour cette nouvelle année également :)

Concernant ton problème, je trouve que tes explications ne sont pas très claire. En effet, on n'appelle ni ne lance une classe. Cela ne veut rien dire.
On appelle des méthodes, et on instancie une classe.

De ce que j'en ai déduis :
- ton IHM contient un bouton "start" qui lance une première vérification
- sans intervention de l'utilisateur, une prochaine vérification aura lieu dans deux heures, et ainsi de suite.
- chaque vérification contient un ensemble de 6 tâches, qui s'écécutent les unes après les autres

Je n'ai pas bien compris les détails de ton problème. Je retiens que ton IHM freeze, et n'affiche pas la bonne progression des tâches.
Corriges moi si j'ai mal compris.

En l'état, il y a une explication à ce problème. Pour ça, il faut comprendre le principe des Threads.
Un thread est un processus léger, qui va pouvoir s’exécuter en parallèle d'un autre thread. Tous les threads partages le même espace de mémoire, c'est à dire qu'il pourront tous accèder aux variables de ton programme (ce qui peut être dangereux si plusieurs threads modifie les même variables, en même temps).

Dans un programme Java, il y a toujours au moins un thread, démarré automatiquement par la JVM; celui qui appèle la méthode static void main(...).

Avec une interface graphique, un autre thread est créé. Celui-ci tourne en boucle, et répètent à l'infini les étapes suivantes:
- dessiner les fenêtres et leur contenu
- contrôler les "inputs" (déplacement de la souris, click sur un bouton etc...)
- appeler les Listeners que tu auras associé aux éléments de ton IHM

Et je suppose que tes 6 contrôles sont appelés dans le listener (et donc par le thread de l'interface). Du coup, tant que le thread n’appellera la fonction pour dessiner l'interface que lorsqu'il sera sortie de la fonction qui appelle tes listeners. Non seulement l'affichage freeze durant toute la durée des contrôles, mais en plus la barre de progression passe de 0% à 100%. Ce qui est normal du coup.

Maintenant que tu comprends le problème, voilà la solution (et ça n'a rien de simple...).
Pour éviter de freezer, il ne faut JAMAIS exécuter de code "lourd" dans les listeners. Ceux-ci doivent rendre la main le plus vite possible, afin que le thread de l'IHM puisse reprendre sa boucle et traiter l'affichage. Cela signifie qu'il faut exécuter les contrôles dans un thread. Le listener se contentera de lancer ce thread. Puis, à chaque tâche terminée, il faut faire l'inverse: informer l'IHM qu'il faut mettre à jour la barre de progression. Et enfin, quand toutes les tâches sont finies, recalculer l'heure de la prochaine vérification.

Tu trouveras toutes les réponses plus détaillées pour SWING ici :
http://gfx.developpez.com/tutoriel/j...ing-threading/

Bonjour

et merci pour votre réponse aussi détaillée et complète.

je vais mettre à profit toutes ces précieuses informations mais également clarifier mes explications.

Voici le code de mon bouton d'appel :
la seconde ligne est là pour vérifier le moment où le l'outil revient sur cet objet. Je n'ai pas implémenté la boucle qui fait que la barre de progression freeze.

en l'état tout fonctionne correctement, la barre de progression évolue correctement en fonction de l'évolution des action (Action1, Action2 ....)

les actions ne sont pas appelées dans le listener de l'IHM mais dans Progress. c est ce qui m'a paru le plus simple à intégrer pour la prise en compte de la barre d'évolution.

Je n'ai pas réussi à trouver une syntaxe qui me permette de dire : exécuter Progress et attendre la fin de son exécution pour poursuivre !!!

Code:

1
2
3
4
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {                                         
new Progress();
System.out.println("retour menante");
}

J'ai essayé ceci mais j'ai une erreur lors de l'exécution

Code:

new Thread((Runnable) new Progress()).start();

le message d'erreur :

Code:

1
2
3
4
Exception in thread "AWT-EventQueue-0" java.lang.ClassCastException: toto.Progress cannot be cast to java.lang.Runnable
	at toto.RFC.Bouton_testActionPerformed(RFC.java:596)
	at toto.RFC.access$1200(RFC.java:44)
	at toto.RFC$13.actionPerformed(RFC.java:286)

Cette seconde partie est celle exécutée lors de la validation sur le bouton :

Code:

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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
package toto;
 
 
 
import static com.sun.org.apache.regexp.internal.RETest.test;
import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javafx.concurrent.Task;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JProgressBar;
import java.util.Timer;
import java.util.TimerTask;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JLabel;
import static jdk.nashorn.internal.objects.NativeRegExp.test;
 
public class Progress extends JFrame{
  public String fin_process;
  public Thread t;
  private JProgressBar bar;
  private JLabel jLabel2;
  private JLabel jLabel3;
  private JLabel jLabel4;
  private JLabel jLabel5;
  private String nom;
  public Progress(){      
 
     this.nom ="toto";
 
    this.setSize(300, 50);
    this.setTitle("frame");
    this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    this.setLocationRelativeTo(null);      
 
    t = new Thread(new Traitement());
 
    bar  = new JProgressBar();
    bar.setMaximum(5);
    bar.setMinimum(0);
    bar.setStringPainted(true);
    //bar.setSize(100,10); 
 
 
   jLabel2 = new javax.swing.JLabel("Action en cours : "); 
   jLabel3 = new javax.swing.JLabel(""); 
   jLabel4 = new javax.swing.JLabel("");
   jLabel5 = new javax.swing.JLabel("");  
        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
        getContentPane().setLayout(layout);
layout.setHorizontalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addGap(27, 27, 27)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                    .addComponent(jLabel4)
                    .addComponent(jLabel3)
                    .addGroup(layout.createSequentialGroup()
                        .addGap(103, 103, 103)
                        .addComponent(bar, javax.swing.GroupLayout.PREFERRED_SIZE, 260, javax.swing.GroupLayout.PREFERRED_SIZE))
 
                        .addComponent(jLabel5)
                    .addComponent(jLabel2))
                .addContainerGap(138, Short.MAX_VALUE))
        );
        layout.setVerticalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addGap(28, 28, 28)
                .addComponent(jLabel2)
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                .addComponent(bar, javax.swing.GroupLayout.PREFERRED_SIZE, 30, javax.swing.GroupLayout.PREFERRED_SIZE)
                .addGap(18, 18, 18)
                .addComponent(jLabel3)
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
                .addComponent(jLabel4)
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                .addComponent(jLabel5)
                .addContainerGap(64, Short.MAX_VALUE))
        );
        t.start();
         System.out.println(", status = " + t.isAlive());
        //t.join();
    this.setVisible(true);
    pack();
 
  }
 
 
  class Traitement implements Runnable{   
    public void run(){
 
 
      for(int val = 0; val <= 5; val++){
        try {
            bar.setValue(val);
                        switch (val) {
            case 0:  new Action1();
 
            jLabel2.setText("Action en cours : vérification de l'incrémentation des fichiers");
            jLabel3.setText("Fichier de ranging bien sauvegardé !");
 
 
            pack();
            break;
            case 1:  new Action2();jLabel2.setText("Action2");
            jLabel2.setText("Action en cours : action2"); 
            jLabel4.setText("Action1 achevé !");
            break;
            case 2:  new Action4();jLabel2.setText("Action3");
            jLabel2.setText("Action en cours : action3");
            jLabel4.setText("ACtion2 achevé !");break;
            case 3:  new Action3();jLabel2.setText("Action4");jLabel2.setText("Action en cours : action3");
            jLabel5.setText("ACtion3 achevé !");break;    
            case 4:  new Action5();jLabel2.setText("Action5");break;
            case 5:  new Action6();jLabel2.setText("Action6");break;    
            }
 
 
 
            try {
                t.sleep(10);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        } catch (InterruptedException ex) {
              Logger.getLogger(Progress.class.getName()).log(Level.SEVERE, null, ex);
        }
      }
setVisible(false);
       System.out.println("fin");
 
 
       System.out.println(", status fin = " + t.isAlive());
       setVisible(false);
    }  
 
 
  }
 
}

Par avance merci

Bon Week end

06/01/2017, 15h41
joel.drigo

Ta classe progress n'implémente pas Runnable, c'est pour ça que tu as une erreur de cast. Ensuite, un thread rend effectivement immédiatement la main après avoir été démarré. Mais ce n'est pas ça qui devrait poser de problème. En revanche, tu te simplifieras la vie si tu fais un SwingWorker au lieu d'un thread : déjà il intègre la gestion de la progression, et la mise à jour de l'affichage est simplifiée (pas besoin d'invokeLater). Pour l'exécution toutes les deux heures, utiliser un Timer ou un SchedulerExecutorService te simplifiera la vie par rapport à un thread avec une boucle et des sleeps.