ProgressBar visible mais un peu tard..

Version imprimable

bonjour,

je vous explique le soucis,

j'ai une interface graphique avec un bouton valider.

En cliquant sur ce bouton, je voudrais faire apparaitre une progressBar en dessous :
Code:

1 2 3 4 5 ProgressBar progressBar = new ProgressBar(groupActif, SWT.INDETERMINATE); progressBar.setMinimum(0); progressBar.setMaximum(20); progressBar.setBounds(new Rectangle(230, 140, 120, 25));
la progressBar apparait bien comme il faut, nickel.

mais le soucis, c'est que juste après avoir mis cette progressBar, je veux faire un traitement, qui lance un pool de threads :
Code:

1 2 3 4 5 6 7 8 9 10 /* on crée un pool de thread pour pinger les adresses */ ExecutorService executor = Executors.newCachedThreadPool(); List<Future> listeFuture = new ArrayList<Future>(); for (int i=0 ; i<nbBus ; i++){ numTBA = listeBus.get(i).getTba(); listeFuture.add(executor.submit(new ThreadPing(numTBA))); }
Ces thread peuvent durer jusqu'à 3 secondes, et une fois ces 3 secondes ecoulées, je recupere des données, que j'affiche sur l'interface :
Code:

1 2 3 4 groupActif.setText("Confirmer"); cLabel = new CLabel(groupActif, SWT.NONE); ...
Les traitements avec les threads marche très bien, une fois qu'ils sont fini j'ai bien le nouvel affichage qui se fait, mais le probleme c'est que la progressbar n'apparait que lorsque tous les autres elements sont chargés et que les threads sont finis, en bref elle sert à rien..

comment se fait il que aucun des elements que j'ajoute a mon Group courant dans le listener ne s'ajoute tout de suite et attende que mon traitement se finisse ?

j'ai essayé avec
Code:

1 2 3 4 isplay.syncExec( new Runnable() { public void run(){
en lancant un thread spécial... rien n'y fait...

quelqu'un a une idée ?

(j'espere avoir été clair, le code fourni est un exemple)

merci d'avance

22/04/2011, 10h02
dumoulex

nouvelle constatation, lorsque je clique sur mon bouton valider qui lance les traitements, rien ne se passe pendant les calculs.. (au niveau graphique).

j'ai testé d'ajouter la barre avant le clique, elle apparait mais des que je clique, elle se fige et ne reprend qu'une fois les calculs finis...

meme depuis un thread... ce qui m'etonne vraiment
22/04/2011, 16h42
sinok

Pour faire simple, tu viens de faire face à quelque chose de classique au niveau interfaces graphiques, les tâches longues (calculs, lecture de fichiers, connexions aux bases de données, tout ce qui implique flux et/ou sockets & cie), quand elles sont effectuées dans le thread de l'interface graphique, bloquent toutes les opérations de dessin. De fait le thread de l'interface graphique ne peut dépiler toute les actions qui lui sont indiquées, dans ton cas la mise à jour de la Scrollbar.

La façon propre de procéder est de faire les calculs dans un thread séparé, et de mettre à jour l'interface graphique depuis ce Thread. Cependant, les toolkits graphiques n'étant pas Thread safe, les méthodes des composants doivent être uniquement appelés depuis le Thread de l'interface graphique. Les toolkit proposent donc toujours des mécanismes permettant d'exécuter une action dans le Thread de l'interface Graphique. En SWT cette méthode est la méthode asyncExec(Runnable R) de la classe Display.

Voici un exemple de la façon de faire:

http://www.java2s.com/Code/JavaAPI/o...unnablerun.htm

Voici le lien officiel expliquant la gestion des interactions SWT/Threading: http://help.eclipse.org/helios/index..._threading.htm

Cependant le serveur d'Eclipse.org semble avoir quelques problèmes aujourd'hui...
26/04/2011, 08h46
dumoulex

ok merci !

j'avais vu cette methode async mais je ne connaissais pas trop. je vais me pencher dessus.

bonne journée a toi !
05/05/2011, 15h37
dumoulex
hello,

J'ai réussi à avoir ma progressbar, je l'affiche dans un nouveau Shell lancé depuis l'application, mais j'ai un autre problème qui est apparu.
A lire sinok, j'avais des problèmes de Thread, effectivement, maintenant c'est OK, mais mon Thread qui gère la ProgressBar bloque le Thread de mon application... :?

Si jamais je tente de couper la fenêtre contenant la ProgressBar, le traitement dans le Thread principal repart...
Je pense qu'il y a des problàmes à cause du Display...
Puisque, pour le moment, la ProgressBar avance mais mon traitement s'arrête, alors que si je commente le bloc :
Code:

1 2 3 4 5 while (!shell.isDisposed()) { if (!display.readAndDispatch()) { display.sleep(); } }
Le traitement va jusqu'au bout mais forcément, la barre n'apparait plus...

Si quelqu'un peut me tirer de cette *** !

Merci d'avance

N'hésitez pas a me demander du code ou plus d'infos.

voila le code complet :

l'appel :

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
 
if (codeRetour==ACK){	
	String nbVideoStr = stringSplit[1];	
	String tailleFichiersStr = stringSplit[2];		
	int nbVideo    = Integer.valueOf(nbVideoStr);
	tailleRestante = Integer.valueOf(tailleFichiersStr);			
 
	FenetreProgressBar mbpb = new FenetreProgressBar(tailleRestante, ihm, this);
	mbpb.start();
 
	for(int y = 0 ; y<nbVideo ; y++){	
 
		requete = recevoirMessage();	
		stringSplit = requete.split(SEPARATOR);	
		codeRetour = Integer.valueOf(stringSplit[0]);
		String nomVideo = stringSplit[1];
		int tailleFic =  Integer.valueOf(stringSplit[2]);
 
		try {
			ret = recuperationVideos(nomVideo, tailleFic);	
		} catch (Exception e) {
			e.printStackTrace();
		}			
 
		System.out.println("recuyperation terminee, envoi ACK");
	}
 
	try {
		if (inBuffer != null){
			inBuffer.close();		
		}
		couperConnexion();
	} catch (IOException e) {
		e.printStackTrace();
	}
				}else{													return codeRetour;
}

le thread :

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
 
 
public class FenetreProgressBar  extends Thread {
 
	private Display display;
	private IHM ihm;
	private Shell shell2;
	private ProgressBar pb1;
 
 
	 public FenetreProgressBar(int taille, IHM ihm, RecuperationVideos recup){
 
		 this.ihm = ihm;
		 Display display = ihm.getDisplay();
 
		 shell2 = new Shell(display);
		 shell2.setLayout(new GridLayout());
 
		 pb1 = new ProgressBar(shell2, SWT.HORIZONTAL | SWT.SMOOTH);
		 pb1.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
		 pb1.setMinimum(0);
		 pb1.setMaximum(30);
 
		 shell2.pack();
		 shell2.open();
 
		 while(!shell2.isDisposed()) {
			 if (!display.readAndDispatch())
				 display.sleep();
		 }
		 display.dispose();
	 }
 
 
	 public void run() {
 
		 display.asyncExec(new Runnable() {
			 public void run() {
 
				 for (int i = 0; i < 3; i++) {
					 try {
						 Thread.sleep(1000);
					 } catch (InterruptedException e) {
					 }
					 if (ihm.getPb1().isDisposed())
						 return;
					 ihm.getPb1().setSelection(ihm.getPb1().getSelection() + 1);
				 }
			 }
		 });
	 }
}

06/05/2011, 09h40
dumoulex
dans le code du thread, si je veux que la nouvelle fenetre apparaisse avec la progressbar, il faut absolument que je mette ca :
Code:

1 2 3 4 5 6 7 while(!shell2.isDisposed()) { if (!display.readAndDispatch()) display.sleep(); } display.dispose();
avec ça, j'ai l'affichage de la barre et son défilement, mais ça bloque le traitement principal...
si je l'enlève, mais le traitement principal se fait bien mais je n'ai pas la barre dans le nouveau shell....
si je l'

Salut,

Je suppose que tu es dans une application SWT (et non RCP ou Eclipse). Donc, ce que tu peux faire c'est utiliser le pattern Obersver / Observable. Ta classe contenant la ProgressBar implémente l'interface java.util.Observer et chacun de tes ThreadPing vont avoir un attribut qui hérite de la classe java.util.Observable:
Classe contenant la ProgressBar:

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
public class MyClass implements Observer {
 
    private ProgressBar myBar;
 
    ...
    /* on crée un pool de thread pour pinger les adresses */
    ExecutorService executor = Executors.newCachedThreadPool();
    List<Future> listeFuture = new ArrayList<Future>();
 
    ThreadPing ping;
    for (int i=0 ; i<nbBus ; i++){
        numTBA = listeBus.get(i).getTba();
        ping = new ThreadPing(numTBA);
        ping.addObserver(this);
        listeFuture.add(executor.submit(new ThreadPing(numTBA)));
    }
 
    ...
 
    public void update(Observable anObservable, Object arguments) {
        // Mise à jour de la progress bar:
        display.asyncExec(new Runnable() {
            public void run() {
                myBar.setSelection(aNUmber);
            }
        });
    }
}

Classe ThreadPing:

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
public class ThreadPing extends Runnable {
 
    private MyObservable observable;
 
    public ThreadPing(final int aNumber) {
        observable = new MyObservable();
        ...
    }
 
    public void run() {
        ...
        // Pendant le traitement, quand on veut notifier la barre de progression:
        observable.setChanged();
        // On peut éventuellement passer un argument aux Observers:
        observable.notifyObservers();
 
        // A la fin du traitement, on enlève les Observers:
        observable.deleteObservers();
    }
 
    public void addObserver(final Observer anObserver) {
        observable.addObserver(anObserver);
    }
}

Classe MyObservable:

Code:

1
2
3
4
5
6
7
8
9
10
public class MyObservable extends Observable {
 
    /**
     * {@inheritDoc}
     */
    @Override
    public void setChanged() {
        super.setChanged();
    }
}

Voilà, à+
Gueritarish

06/05/2011, 10h37
dumoulex

merci de ta réponse, oui c'est du SWT

j'ai du mal à voir toutes les subtilités de ta solution ! surtout que je ne suis plus trop avec le pool de thread !

j'utilise la progressBar ailleurs.

je pense que ta classe Observable peut m'être utile effectivement. mais la je cherche vraiment à faire un exemple le plus simple possible par ce que cette progressbar commence à me souler !

même sans bouger le niveau de la barre, ca plante...

pourtant c'est bidon ce que je veux faire...
je veux simplement, avant de lancer un traitement, qu'un nouveau shell soit créé avec une progressbar qui avance dedans... c'est bidon quand même...

pour le moment je pense même pas à calculer sa vitesse ou changer sa valeur depuis d'autres endroits !

j'ai posté le code actuel à 9h37, tu peux constater que je lance une classe qui doit lancer le shell avec la progressbar, et la faire avancer tranquillement (sans autre calcul d'aucune sorte)

pendant ce temps, le thread principal appelle la fonction recuperationVideos qui fait ses traitements de son coté.

Rien ne marche avec ca, j'ignore pourquoi, mais soit j'ai l'affichage de la barre, soit j'ai le traitement... impossible d'avoir les 2

Il "suffit" de bien comprendre dans quel Thread tu te trouves. En l'occurrence, je suis sur que tu fais ton start() après un évènement (donc, dans un Listener). Or, dans une méthode de listener, tu es dans le Thread IHM. Et depuis ce thread, tu vas lancer un autre thread qui va avoir une boucle de dispatch (qui va donc reprendre le dessus sur le thread IHM) dans laquelle en plus, tu vas demander des sleep(1000).
En gros, c'est un micmac pas possible...
Alors, qu'en fait tout se résume à ça:
Je suis dans le thread IHM, j'ouvre un autre Shell contenant une barre de progression et en parallèle je lance une exécution de Thread. Dans cet autre Thread, je vais avoir un observable. J'enregistre ma barre de progression auprès de cet observable et je serais notifié de tout les changements.

Voici un exemple complet ;)
Je te laisse jeter un oeil là dessus pour bien comprendre les mécanismes...

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
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
import java.util.Observable;
import java.util.Observer;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.layout.RowLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.ProgressBar;
import org.eclipse.swt.widgets.Shell;
 
/**
 * 
 * Last Modification Date : May 6, 2011
 * 
 */
public class Test {
 
    /**
     * <p>
     * 
     * @param args
     */
    public static void main(String[] args) {
        final Display display = new Display();
        Shell shell = new Shell(display);
        shell.setText("Launching Progress Bar");
        Button button = new Button(shell, SWT.PUSH);
        button.setText("Launch Progress...");
        final ExecutorService threadExecutor = Executors.newFixedThreadPool(2);
        button.addSelectionListener(new SelectionAdapter() {
            public void widgetSelected(SelectionEvent e) {
                // Thread IHM
                ProgressClass myProgress = new ProgressClass(display);
                ThreadPing thread = new ThreadPing("number 1");
                ThreadPing thread2 = new ThreadPing("number 2");
                thread.addObserver(myProgress);
                thread2.addObserver(myProgress);
                // je lance 2 traitements en parallèle qui vont tout les 2 notifier la même ProgressBar.
                threadExecutor.execute(thread);
                threadExecutor.execute(thread2);
            }
        });
        shell.setLayout(new RowLayout());
        shell.pack();
        shell.open();
        while (!shell.isDisposed()) {
            if (!display.readAndDispatch())
                display.sleep();
        }
        display.dispose();
        threadExecutor.shutdownNow();
    }
 
    static class ProgressClass implements Observer {
 
        // Constructor.
        /**
         * Constructor
         * 
         * @param aDisplay
         *            the Display to use.
         */
        public ProgressClass(Display aDisplay) {
            display = aDisplay;
            createContents();
        }
 
        /**
         * The display to use.
         */
        private Display display;
 
        /**
         * The ProgressBar to monitor.
         */
        private ProgressBar progressBar;
 
        /**
         * <p>
         * Create the contents of this Progress Shell.
         * </p>
         */
        private void createContents() {
            Shell shell = new Shell(display);
            shell.setLayout(new GridLayout());
            shell.setText("Progress bars in action");
 
            progressBar = new ProgressBar(shell, SWT.HORIZONTAL | SWT.SMOOTH);
            progressBar.setLayoutData(new GridData(SWT.FILL, SWT.TOP, true,
                    false));
            progressBar.setMinimum(0);
            progressBar.setMaximum(100);
 
            shell.pack();
            shell.open();
        }
 
        /*
         * (non-Javadoc)
         * 
         * @see java.util.Observer#update(java.util.Observable,
         * java.lang.Object)
         */
        @Override
        public void update(final Observable o, final Object arg) {
            display.asyncExec(new Runnable() {
                public void run() {
                    if (progressBar != null && !progressBar.isDisposed()) {
                        System.out.println("Event received from " + o);
                        System.out.println("Value: " + arg);
                        int selection = progressBar.getSelection();
                        progressBar.setSelection(selection
                                + ((Double) arg).intValue());
                    }
                }
            });
        }
    }
 
    static class ThreadPing implements Runnable {
 
        /**
         * Constructor
         * 
         * @param aName
         *            the Thread name.
         */
        public ThreadPing(String aName) {
            myObservable = new MyObservable(aName);
        }
 
        /**
         * The Observable object.
         */
        private MyObservable myObservable;
 
        /**
         * <p>
         * Add an Observer to notify.
         * </p>
         * 
         * @param anObserver
         *            the Observer to notify.
         */
        public void addObserver(final Observer anObserver) {
            myObservable.addObserver(anObserver);
        }
 
        /*
         * (non-Javadoc)
         * 
         * @see java.lang.Runnable#run()
         */
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(500);
                    myObservable.setChanged();
                    double random = Math.random();
                    // Send a value from 0 to 10
                    myObservable.notifyObservers(random * 10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            myObservable.deleteObservers();
            System.out.println("Action finished");
        }
    }
 
    static class MyObservable extends Observable {
        /**
         * Constructor
         * 
         * @param aName
         */
        public MyObservable(String aName) {
            name = aName;
        }
 
        /**
         * The observable name.
         */
        private String name;
 
        /*
         * (non-Javadoc)
         * 
         * @see java.util.Observable#setChanged()
         */
        @Override
        public void setChanged() {
            super.setChanged();
        }
 
        /*
         * (non-Javadoc)
         * 
         * @see java.lang.Object#toString()
         */
        @Override
        public String toString() {
            return "I'm thread " + name;
        }
    }
}

Voilà, à+
Gueritarish

06/05/2011, 11h55
dumoulex

merci beaucoup !!!! :ccool:

je viens de tester dans eclipse direct ton exemple, c'est pile poil ce que je cherchais, je viens d'adapter tout ça et ça marche ! je vais pouvoir faire tout ce que je dois/veux faire !

Je te remercie sincèrement, parce que c'est dur de trouver de la bonne doc sur SWT ! (quand on enlève tes posts sur developpez.com !)

j'y serais pas arrivé tout seul... il faut dire que plus de 200 lignes pour une progressBar... >.<

Bonne journée