[Threads] affichage de fenêtre

Version imprimable

07/07/2005, 14h05
The Wretched

[Threads] affichage de fenêtre
Bonjour.

J'ai une application qui effectue un travail , et je veux pendant ce temps créer une fenêtre d'attente.
J'ai donc créé une classe :
Code:

1 2 3 public class fenwait implements Runnable {...}
Avec, dans le code de Start, ceci:
Code:

1 2 3 this.thread = new Thread(this); this.thread.start();
La méthode run de cette classe lance le travail, donc dans un nouveau Thread, et la fenêtre d'attente s'affiche bien. Cependant, une fois la fenêtre d'attente affichée, le thread principal continue a tourner et, vu que j'ai une boucle sur mon travail, le programme du thread principal me relance le travail, ce que je ne veux pas (au bout de 2-3 travaux simultanés, j'ai une erreur de mémoire).

J'ai essayé de lancer la fenêtre dans le nouveau Thread et le travail dans le thread principal (comme ca mon programme principal ne se continue pas tant que le travail n'est pas fini), mais la fenêtre s'affiche en gris.(titre et dimensions sont ok, mais aucun contenu :? )
Auriez vous une piste?

Merci d'avance.

ps: désolé si je me suis trompé de partie de forum
07/07/2005, 14h18
sozie9372

Salut !
Est-ce que tu pourrais mettre le bout de code où tu appelles ta fenwait stp ? Je ne pense pas que ca vienne du thread en lui-même, ca doit plutôt venir de ton appel. Généralement, les fenêtres d'attente sont appelées et détruites par les classes qui "travaillent".
+++
Ju

Dans le cas ou je créé la fenêtre dans le nouveau thread et que je lance le travail dans le thread principal, a un moment de mon programme je fais

Code:

1
2
 
fenwait fwait = new fenwait();

afin de créer la fenêtre et de l'afficher.
Je fais ensuite

Code:

1
2
 
fwait.start(/*liste des arguments*/);

Si vous voulez le code de mon run:

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
 
public void run() 
	{ 
 
		jf = new JFrame();
		jf.setTitle("Traitement en cours...");
		jf.getContentPane().setLayout(null);
 
		JLabel labpatientez = new JLabel("<html><B><H3>&nbsp;&nbsp;Veuillez patienter: <BR>Traitement en cours...</H3></B></html>");
		labpatientez.setBounds(new Rectangle(20,0,180,80));
 
		UIManager.put("ProgressBar.cycleTime", new Integer(1000));
		UIManager.put("ProgressBar.repaintInterval", new Integer(10));
		JProgressBar jpb = new JProgressBar();
		jpb.setBounds(new Rectangle(20, 80, 160, 20));
		jpb.setIndeterminate(true);
		jpb.setBackground(Color.WHITE);
 
		jf.getContentPane().add(jpb);
		jf.getContentPane().add(labpatientez);
		jf.setBounds(400,250,200,150);
		jf.getContentPane().setBackground(Color.white);
		jf.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
		jf.setCursor(new Cursor(Cursor.WAIT_CURSOR));
		jf.setVisible(true);
	}

Voila... Merci :)

07/07/2005, 15h49
sozie9372

J'avoue que je ne capte pas trop le problème... En fait, je voulais voir le code qui entoure le moment où tu lances ton thread (ce qu'il y a autour de fen.start())... Excuse moi j'ai pas été très clair...
Dis moi ton "travail", tu le lances quand ? dans ta boucle ? autre part ?

Je sais pas si tu connais, mais il y a deux méthodes, invokeLater et invokeAndWait avec en paramètre un objet Runnable qui sont utilisées lorsque l'on utilise des interfaces graphiques. (cf faq : http://java.developpez.com/faq/java/...angage_threads)

Excuse moi si je suis Hors sujet, mais j'ai un peu de mal à comprendre le problème...
Bon courage
+++
Ju
07/07/2005, 16h27
The Wretched
Je vais essayer d'expliquer un peu mieux:
J'ai un programme principal (on va l'appeler A), dans lequel j'appelle un programme secondaire (B) en boucle.
(en gros, pour résumer:
Code:

1 2 3 4 5 6 7 8 public A() { for(int i =0;i<3;++i) { B(i); } } )
Le programme B prend pas mal de temps et de mémoire, je ne peux donc pas lancer les différentes occurences de B (a cause de la boucle, et en créant un nouveau thread a chaque fois) en parallèle, sinon j'ai une erreur de mémoire insuffisante.
Je dois donc les lancer les uns apres les autres.
Jusque la, pas de problème, suffit de pas créer de thread et d'appeler B dans le thread de A, a l'aide d'une boucle.
Mais, comme ce programme est long, je veux en même temps créer une fenêtre d'attente et l'afficher, ainsi que la faire disparaitre a la fin de B.
Le problème, c'est que si je créé la fenêtre avant d'appeler B et si je la détruit apres, seul le titre s'affiche sur ma fenêtre, avec la bonne dimension, mais sans aucun contenu.
Je suis donc obligé, afin d'afficher correctement cette fenêtre, de créer un nouveau thread dans lequel je lance B. Ainsi, la fenêtre s'affiche correctement.
Mais, si je créé un thread pour B, le thread de A continue en parallèle et me relance B (a cause de la boucle for), et donc cela me génère au bout d'un moment une erreur de mémoire.

En fait j'aimerais surtout comprendre pourquoi la fenêtre, bien que créée avant le lancement de B, ne s'affiche pas en entier.

Merci de tes réponses, je vais de ce pas regarder les invokeLater et invokeAndWait :)

Merci pour tes explications, ca s'éclaircit dans ma tête, j'suis un peu rouillé en Java (Obligé de faire du VB6 en ce moment :cry: ).
J'ai trouvé un topic qui explique pourquoi ton interface est bloquée ou ne s'affiche pas.
D'après le site de sun :

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
 
/**
 * Create the GUI and show it.  For thread safety,
 * this method should be invoked from the
 * event-dispatching thread.
 */
private static void createAndShowGUI() {
    //Make sure we have nice window decorations.
    JFrame.setDefaultLookAndFeelDecorated(true);
 
    //Create and set up the window.
    frame = new JFrame("FocusConceptsDemo");
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
    //Create and set up the content pane.
    JComponent newContentPane = new FocusConceptsDemo();
    newContentPane.setOpaque(true); //content panes must be opaque
    frame.setContentPane(newContentPane);
 
    //Display the window.
    frame.pack();
    frame.setVisible(true);
}
 
public static void main(String[] args) {
    //Schedule a job for the event-dispatching thread:
    //creating and showing this application's GUI.
    javax.swing.SwingUtilities.invokeLater(new Runnable() {
        public void run() {
            createAndShowGUI();
        }
    });
}

Ils t'expliquent comment faire et le but de l'utilisation d'invokeLater:
http://java.sun.com/docs/books/tutor...c/threads.html
Je pense que ca doit répondre à ton problème... ?
+++
Ju

07/07/2005, 17h09
The Wretched

Merci beaucoup, je pense que je vais y arriver, je connaissais pas la méthode invokeLater :oops:

Merci encore, je reviendrai si ca marche toujours pas :D

Moi j'ai un truc comme ça:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
public class Travail extends Thread {
 
  public void run() {
    ...
 
    int nbTask = ...
    VeuillezPatienter vp = new VeuillezPatienter(fenetrePrincipale, "Veuillez patienter pendant la construction de la page.", nbTask);
 
   ...
   // par exemple
 
    for(int i=0; i<...; i++) {
      ...
      vp.updateProgressBar(null);
      ...
    }
 
    vp.dispose();
  }

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
 
import javax.swing.*;
import java.awt.*;
 
 
public class VeuillezPatienter extends Dialog {
  private JProgressBar progressBar;
 
  public VeuillezPatienter(JFrame owner, String titre, int numberTasks) {
    super(owner, titre, false);
 
    progressBar = new JProgressBar(0, numberTasks);
    progressBar.setValue(0);
    progressBar.setStringPainted(true);
    add(progressBar, null);
 
    setBounds(250, 250, 400, 60);
    setResizable(false);
    setVisible(true);
  }
 
  public void updateProgressBar(String message) {
    progressBar.setValue(progressBar.getValue()+1);
 
    if (message != null)
      progressBar.setString(message);
  }
}

Notes: fenetrePrincipale est ta JFrame principale.
nbTasks est ne nombre de taches

Ce que ca fait:

Ton programme tourne normalement. Le travail se met en thread, et j'affiche en premier plan une petite fenetre temporaire qui est une barre de progression.
Quand le travail est fini, cette petite fenetre disparait.

@Billynirvana:
Le problème de ton programme est que je ne connais pas la durée du travail, je ne peux donc pas définir jusqu'a combien ira la boucle for. De plus, a moins qu'il y ait une différence entre appeler une classe qui dérive de Dialog et créer dans le run une JFrame, cela ne résoudra pas mon problème, a savoir une fenêtre vide.

J'ai essayé ceci:

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
 
//ouverture d'une fenetre patientez
 
fenwait fwait = new fenwait();
 
try
{
	//affichage de la fenêtre
	EventQueue.invokeAndWait(fwait);
}
catch(InterruptedException ie)
{
	System.out.println("erreur d'interruption: "+ie);
	ie.printStackTrace();
}
catch(InvocationTargetException ite)
{
	System.out.println("InvocationTargetException: "+ite);
	ite.printStackTrace();
}
 
//on fait la requête.
new travail(/*liste de paramètres*/);
 
fwait.getFrame().dispose();

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
 
import java.awt.Color;
import java.awt.Cursor;
import java.awt.Rectangle;
import javax.swing.*;
 
public class fenwait implements Runnable 
{
	private Thread thread; 
	private JFrame jf;
 
 
	public fenwait() 
	{ 	
		JFrame jf = new JFrame();
		jf.setTitle("Traitement en cours...");
		jf.getContentPane().setLayout(null);
 
		JLabel labpatientez = new JLabel("<html><B><H3>&nbsp;&nbsp;Veuillez patienter: <BR>Traitement en cours...</H3></B></html>");
		labpatientez.setBounds(new Rectangle(20,0,180,80));
 
		UIManager.put("ProgressBar.cycleTime", new Integer(1000));
		UIManager.put("ProgressBar.repaintInterval", new Integer(10));
		JProgressBar jpb = new JProgressBar();
		jpb.setBounds(new Rectangle(20, 80, 160, 20));
		jpb.setIndeterminate(true);
		jpb.setBackground(Color.WHITE);
 
		jf.getContentPane().add(jpb);
		jf.getContentPane().add(labpatientez);
		jf.setBounds(400,250,200,150);
		jf.getContentPane().setBackground(Color.white);
		jf.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
		jf.setCursor(new Cursor(Cursor.WAIT_CURSOR));
	} 
	public void start() 
	{ 
		if(this.thread == null) 
		{ 
			this.thread = new Thread(this); 
			this.thread.start(); 
		} 
 
 
	} 
	public void run() 
	{ 
 
		jf.setVisible(true);
 
	}
                public JFrame getFrame()
	{
		return(this.jf);
	}
 
}

Donc, normalement, je créé ma fenêtre, sans l'afficher, puis je l'affiche lors du InvokeAndWait, et j'attend que cette fenêtre soit bien affichée, puis je fais mon travail, et, apres le travail, je referme la fenetre.

Ceci me génère une exception que 'ai du mal a comprendre:
"java.lang.Error: Cannot call invokeAndWait from the event dispatcher thread"

Pourriez vous m'expliquer cette erreur?

Merci d'avance :)

08/07/2005, 09h53
billynirvana

Oui je vois, mais tu peut mettre le temps de travail à 100 itérations et tu fais des approximations. J'ai vu dans un tutorial une barre de progression dont le temps de l'algo est de durée inconnue. Vois avec Google, c'est sur un truc en anglais que j'ai vu ça...

rebonjour
Ca commence a m'énerver ca :evil:
Je comprend plus a quoi servent les threads la...
Je créé un nouveau thread, qui créé une fenêtre:
code de la fenêtre:
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 public class fenwait implements Runnable { public fenwait() { } public void start() { Thread thread; thread = new Thread(this); thread.start(); } public void run() { JFrame jf = new JFrame(); jf.setTitle("Traitement en cours..."); jf.getContentPane().setLayout(null); JLabel labpatientez = new JLabel("<html><B><H3>  Veuillez patienter: <BR>Traitement en cours...</H3></B></html>"); labpatientez.setBounds(new Rectangle(20,0,180,80)); UIManager.put("ProgressBar.cycleTime", new Integer(1000)); UIManager.put("ProgressBar.repaintInterval", new Integer(10)); JProgressBar jpb = new JProgressBar(); jpb.setBounds(new Rectangle(20, 80, 160, 20)); jpb.setIndeterminate(true); jpb.setBackground(Color.WHITE); jf.getContentPane().add(jpb); jf.getContentPane().add(labpatientez); jf.setBounds(400,250,200,150); jf.getContentPane().setBackground(Color.white); jf.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE); jf.setCursor(new Cursor(Cursor.WAIT_CURSOR)); jf.setVisible(true); } public JFrame getFrame() { return(this.jf); } }
Ensuite je l'appelle depuis mon programme principal:
Code:

1 2 3 4 5 6 //ouverture d'une fenetre patientez fenwait fwait = new fenwait(); //affichage de la fenêtre fwait.start();
puis je fais un Thread.sleep(10000) dans mon programme principal.
Et enfin je fais un System.out.println("test");

Si je comprend bien l'intêret des threads, normalement ce que j'appelle en faisant fwait.start tourne en parallèle de mon Thread.sleep du programme principal non?
Pourtant il n'y a que le titre et le cadre de ma fenêtre qui s'affichent, et le reste s'affiche uniquement apres le "test" !!
Aurais-je fait une erreur de raisonnement :?:

J'aimerais bien comprendre pourquoi l'affichage de la fenêtre se fait en différé :?
Merci

11/07/2005, 17h45
The Wretched

Bonjour

Je me permet de faire remonter ce post et de reformuler ma question:
Y a-t-il un moyen de créer un thread qui affiche une fenêtre , puis d'effectuer un travail dans le thread principal, et ceci UNIQUEMENT apres que la fenêtre se soit entièrement affichée?

ps:
@billynirvana: Cela ne marchera pas pour moi car le travail est lancé dans un nouveau thread, et pendant ce temps la, le programme principal continue a tourner... (vu que j'ai une boucle sur mon travail, le programme me lance une erreur de mémoire au bout d'un temps).

Si vous avez des idées pour résoudre ce problème ou le contourner, merci d'avance.

G du mal a cerner ce que tu veux faire exactement, mais voici un exemple pour lancer un traitement dans une Frame en parrallele du traitement principal.

Pour la frame, on derive la classe de JFrame. Pour executer le process en parallele, on implemente l'interface Runnable.

Le traitement est localisé dans la Frame-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 import javax.swing.JFrame; import javax.swing.JLabel; import javax.swing.JPanel; public class FenWait extends JFrame implements Runnable { private JLabel lab1 = new JLabel(""); public FenWait() { super("Traitement en cours..."); JPanel j = new JPanel(); j.add(new JLabel("Traitement en cours...")); j.add(lab1); getContentPane().add(j); } public void run() { setVisible(true); lab1.setText(""); try { Thread.sleep(2000); lab1.setText("YESSSSS!"); Thread.sleep(3000); } catch (InterruptedException ex) { ex.printStackTrace(); } setVisible(false); } }
Le traitement est ici limité à un sleep de 5 secondes avec une modification d'un label de la Frame au milieu pour montrer qu'elle est bien rafraichie pendant l'execution.

Et voici la classe principale pour tester le bignou :
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 import java.awt.event.*; import javax.swing.*; public class MainFrame extends JFrame { private static FenWait fw; private static int nb = 0; private JLabel lab1 = new JLabel(""); public MainFrame() { this.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }); buildPanel(); pack(); } private void buildPanel() { JPanel panel = new JPanel(); JButton b1 = new JButton("Lancer job"); b1.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { Thread T = new Thread(fw); T.start(); } }); JButton b2 = new JButton("Faire autre chose"); b2.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { nb++; lab1.setText(Integer.toString(nb)); } }); panel.add(b1); panel.add(b2); lab1.setText(Integer.toString(nb)); panel.add(lab1); getContentPane().add(panel); } public static void main(String[] args) { MainFrame dl = new MainFrame(); dl.setSize(400, 300); dl.setVisible(true); fw = new FenWait(); fw.setSize(400, 300); fw.setVisible(false); } }
Si tu veux lancer plusieurs traitements a la suite, tout en continuant a faire autre chose dans la fenetre principale, tu place ta boucle dans la methode run de la Frame-Thread.

Dans l'exemple j'ai egalement mis un bouton pour incrementer un compteur et montrer ainsi que l'on peut continuer a travailler pendant l'execution du traitement.