IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Concurrence et multi-thread Java Discussion :

[Threads] affichage de fenêtre


Sujet :

Concurrence et multi-thread Java

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre confirmé
    Profil pro
    Inscrit en
    Mars 2005
    Messages
    100
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2005
    Messages : 100
    Par défaut [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 : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
     
    public class fenwait implements Runnable 
    {...}
    Avec, dans le code de Start, ceci:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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

  2. #2
    Membre émérite Avatar de sozie9372
    Inscrit en
    Mai 2005
    Messages
    713
    Détails du profil
    Informations personnelles :
    Âge : 42

    Informations forums :
    Inscription : Mai 2005
    Messages : 713
    Par défaut
    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

  3. #3
    Membre confirmé
    Profil pro
    Inscrit en
    Mars 2005
    Messages
    100
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2005
    Messages : 100
    Par défaut
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    fenwait fwait = new fenwait();
    afin de créer la fenêtre et de l'afficher.
    Je fais ensuite
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    fwait.start(/*liste des arguments*/);
    Si vous voulez le code de mon 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
    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

  4. #4
    Membre émérite Avatar de sozie9372
    Inscrit en
    Mai 2005
    Messages
    713
    Détails du profil
    Informations personnelles :
    Âge : 42

    Informations forums :
    Inscription : Mai 2005
    Messages : 713
    Par défaut
    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

  5. #5
    Membre confirmé
    Profil pro
    Inscrit en
    Mars 2005
    Messages
    100
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2005
    Messages : 100
    Par défaut
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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

  6. #6
    Membre émérite Avatar de sozie9372
    Inscrit en
    Mai 2005
    Messages
    713
    Détails du profil
    Informations personnelles :
    Âge : 42

    Informations forums :
    Inscription : Mai 2005
    Messages : 713
    Par défaut
    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 ).
    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 : 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
     
    /**
     * 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

  7. #7
    Membre confirmé
    Profil pro
    Inscrit en
    Mars 2005
    Messages
    100
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2005
    Messages : 100
    Par défaut
    Merci beaucoup, je pense que je vais y arriver, je connaissais pas la méthode invokeLater

    Merci encore, je reviendrai si ca marche toujours pas

  8. #8
    Membre chevronné Avatar de billynirvana
    Homme Profil pro
    Architecte technique
    Inscrit en
    Décembre 2004
    Messages
    472
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Architecte technique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Décembre 2004
    Messages : 472
    Par défaut
    Moi j'ai un truc comme ça:

    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
     
    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 : 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
     
    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.

  9. #9
    Membre confirmé
    Profil pro
    Inscrit en
    Mars 2005
    Messages
    100
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2005
    Messages : 100
    Par défaut
    @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 : 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
     
    //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();
    et

    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
     
    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

  10. #10
    Membre chevronné Avatar de billynirvana
    Homme Profil pro
    Architecte technique
    Inscrit en
    Décembre 2004
    Messages
    472
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Architecte technique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Décembre 2004
    Messages : 472
    Par défaut
    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...

  11. #11
    Membre confirmé
    Profil pro
    Inscrit en
    Mars 2005
    Messages
    100
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2005
    Messages : 100
    Par défaut
    rebonjour
    Ca commence a m'énerver ca
    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 : 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
     
    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>&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);
    	}
    	public JFrame getFrame()
    	{
    		return(this.jf);
    	}
    }
    Ensuite je l'appelle depuis mon programme principal:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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

  12. #12
    Membre confirmé
    Profil pro
    Inscrit en
    Mars 2005
    Messages
    100
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2005
    Messages : 100
    Par défaut
    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.

  13. #13
    Futur Membre du Club
    Profil pro
    Inscrit en
    Juillet 2005
    Messages
    5
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juillet 2005
    Messages : 5
    Par défaut
    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 : 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
     
    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 : 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
     
    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.

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. thread affichage jsp
    Par youp_db dans le forum Servlets/JSP
    Réponses: 7
    Dernier message: 17/10/2006, 16h00
  2. Affichage d’une fenêtre d’erreur
    Par rastam dans le forum Access
    Réponses: 6
    Dernier message: 19/07/2006, 16h09
  3. Réponses: 5
    Dernier message: 30/03/2006, 11h59
  4. Réponses: 2
    Dernier message: 26/01/2006, 21h59
  5. [Kylix] Problème d'affichage de fenêtres
    Par Progs dans le forum EDI
    Réponses: 1
    Dernier message: 01/01/2005, 02h46

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo