Discussion :

[bflash2k]

Bonjour,
Je viens de debuter en Java (JRE 1.5) avec l'IDE Netbeans5.5.
Je developpe une appli qui affiche des messages en provenance d'une autre application.
Le principe est le suivant:
L'appli A envoie à travers le reseau, en TCP des trames de traces. Ces trames sont composées de plusieurs blocs (un bloc avec le datetime, un bloc avec le processID, etc...)

Mon appli receptrice en JAVA est concue de la facon suivante:
Une classe Main

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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94



/* -------------------------------------------------------------- */
public class Main extends JFrame
        implements ActionListener {
    public  JDesktopPane _desktop;
    public  JMenuBar _menuBar;
    public  MyWaitingThread _kWaitServer;
  

    /* ------------------------- 
     * Main constructor
     * ------------------------- */
    public Main() {
        super("Java Test - V:0.02 ");
        
        //Make the big window be indented 50 pixels from each edge
        //of the screen.
        int inset = 50;

        Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
        setBounds(inset, inset, screenSize.width  - inset*2,
                screenSize.height - inset*2);
        
        //Set up the Main panel.
        _desktop = new JDesktopPane(); //a specialized layered pane
           //Add the desktop pane to this panel.
        setContentPane(_desktop);
        
        // Set the menu bar
        setJMenuBar(createMenuBar());
                    
        //Make dragging a little faster but perhaps uglier.
        _desktop.setDragMode(JDesktopPane.OUTLINE_DRAG_MODE);
        
        // Launch the waiting thread
        _kWaitServer = new MyWaitingThread(this);
        _kWaitServer.start();
    }
     
    /* ------------------------- 
     * React to menu selections.
     * ------------------------- */
    public void actionPerformed(ActionEvent e) {
       .... du code ici ....
    }
            
    /* -------------------------
     * Prepare the menu bar
     * ------------------------- */
    protected JMenuBar createMenuBar() {
       ... mon menu créé ici ...
        return menuBar;
    }
    
    //Show About dialog
    protected void ShowAboutDialog() {
        .... .....
    }  
   
    //Quit the application.
    protected void quit() {
        System.exit(0);
    }
    
    /*
     * 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.
        Main frame = new Main();
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        
        //Display the window.
        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();
            }
        });
    }
}

...donc du trés classique. MyWaitingThread est un thread qui boucle en attente sur une socket. Plusieurs "clients" peuvent se connecter pour envoyer leurs traces. Chacun de ces clients apparaitra dans une JInternalFrame.

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 void run() {
        DebugInf.println("Entering Waiting thread...");
        ServerSocket serverSocket = null;
 
        try {
            serverSocket = new ServerSocket(12345);
 
            while (bLoop) {
                // We waiting for socket, and run the thread...
                Socket asocket = serverSocket.accept();              
                if (iThreadsCounter < MAXTHREADS)
                { 
                        DebugInf.println("Created Frame for thread #" + iThreadsCounter);
                        new KWorkingThread(localWnd ,asocket,iThreadsCounter).start();
                        iThreadsCounter ++;                                  
                }
            }
            serverSocket.close();
        }

Donc, à chaque nouveau client, un nouveau thread (KWorkingThread) est lancé. Ce KWorkingThread va donc creer une DisplayFrame, lire les données qui arrivent, les décortiquer puis appeler iDisplayFrame.addTrace

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
 
   public DisplayFrame() {
        super("Document #" + (openFrameCount),
                true, true, //resizable & closable
                true, true); //maximizable & iconifiable
 
        try{
            //...Create the GUI and put it in the window...
            //...Then set the window size or call pack...
            openFrameCount++;
 
            setSize(400,400);
            //Set the window's location.
            setLocation(xOffset*openFrameCount, yOffset*openFrameCount);
 
            //Create the list box
            // Create some items to add to the list
            _listData = new Vector();
            //Vector<String> listData = new Vector<String>();
            _listData.addElement("Start.");
            _listData.addElement("------");
            //Add the list box to the Pane
            _theListBox = new JList(_listData);
            _scrollPane = new JScrollPane();
            _scrollPane.getViewport().add(_theListBox);
            this.getContentPane().add(_scrollPane);
        } catch (Exception e) {return;}
    }

...et chaque appel pour afficher une trace se fait de la facon suivante:

Code :

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

1
2
3
4
5
 
    public void addTrace(myTraceString) {
        _listData.addElement(myTraceString);
        _theListBox.setListData(_listData);
}

Cela fait approximativement ce que je veux MAIS j'ai des soucis :
- j'ai des performances TRES NULLES (100% du cpu avec juste 4 fenetres simultanement)
- Dans certains cas, sous ubuntu par exemple, j'ai des fenetres qui restent vide (normal, je ne fait pas de repaint pour ne pas ralentir encore plus)
- J'ai des fois des frames qui restent en arriere plan et refusent de passer devant !
et la question bonus: j'aimerai rajouter une toolbar ...mais j'ai des soucis d'occupation de surface par mes frames...

Merci beaucoup pour votre aide!
Amicalement
Olivier

[broumbroum]

quand tu lances le Thread KWorkingThread, je pense que ca pose un probleme de surcharge memoire pour la JVM. A ce moment la, tu devrais surveiller l execution des Threads d'une maniere plus precise. par exemple tu pourrais les ajouter a une List et ainsi garder une trace de chacun.
En particulier lorsque l'un de ceux - ci se termine, l evacuer de la memoire residente.

[xavlours]

Bonjour,

l'appli que tu décris ne devrait pas consommer énormément de ressources. Il doit y avoir un problème.

Deux propositions :
- _listdata ne devrait pas être un Vector, mais un DefaultListModel. Ca fonctionne exactement pareil, sauf qu'avec le principe des Listeners, tu n'as plus besoin d'appeler setListData après add. Selon la taille de la liste, tu peux gagner un temps significatif dans l'EDT (le thread graphique) : tu ne rafraîchis qu'une partie de la liste au lieu de la liste entière.
- Le code que tu mets dans actionPerformed, si il est trop long, peut lui aussi bloquer l'EDT.

Une dernière chose : tu peux mettre les données en brut dans la JList (dans un objet qui soit très facile à remplir par le thread du socket). Ensuite, tu redéfinis un ListCellRenderer pour tes JList. L'avantage ici, c'est que tu ne traites pas les données au moment de leur réception, mais au moment de leur affichage. Les données non lues ne seront pas moulinées.

En espérant t'aider.