Discussion :

[Invité]

Bonjour,

Je tente de créer un "gestionnaire de processus". Ce gestionnaire doit posséder une pile de processus en attente. Le gestionnaire peux faire tourner au maximum N processus simultanés.

Pour cela j'ai ecris 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
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
 
// pile est une LinkedList
// Process implémente Runnable
public void run() {
        run = true;

        while ( run ) {
            
            if ( pile.size()>0 && getActiveCount()<MAX_PROCESS ) {
                try {
                    Process p = pile.getFirst();
                    new Thread(p).start();
                    pile.removeFirst();
                } 
                catch ( NoSuchElementException e ) {}
            } 
            else {            
                try {
                    synchronized (this) {
                        System.out.println("wait : \n\t" + 
                                "size : " + p.size() + "\n\t" +
                                "actifs : " + getActiveCount()
                                );
                        wait();                         
                    }
                }   
                catch ( InterruptedException e ) {
                    e.printStackTrace();
                    run = false;
                }                
            }
        }              
    }

//Lorsqu'un processus est ajouté à la pile ou qu'un processus est terminé, je //fais un notifyAll.
// La gestionnaire implémente ProcessListener (qui écoute les évènements d'un processus)

 public void register(Process p) {
        if ( p== null)
            throw new NullPointerException();
        
        synchronized (this) {
            p.addProcessListener(this);
            pile.addLast(p);
            fireProcessAdded(p);            
        }
    }

public void processFinished(Process p) {
        pile.remove(p);
        synchronized (this) {
            actifs --;
            notifyAll();
        }
// Il y à aussi un listener pour le gestionnaire qui doit-être prévenu lorsqu'une conversion est terminée.
        fireProcessFinished(p);
    }

Malheureusement, je dois ajouter troisProcesss avant que le gestionnaire ne commence à les démarrer.

run:
Active count 0
wait :
size : 0
actifs : 0
Enregistre le process : PremierProcess
Active count 0
wait :
size : 0
actifs : 0
PremierProcess démarrer.
PremierProcess essais : 13

Enregistre le process: SecondProcess
Active count 1
wait :
size : 0
actifs : 1
SecondProcess démarrer.
SecondProcess essais : 7

Enregistre le process: TroisiemeProcess
Active count 2
wait :
size : 1
actifs : 2
tentative 0 de 7
tentative 0 de 13
tentative 1 de 7
tentative 1 de 13
....

SecondProcess termine apres 1185284414699 ms
SecondProcess terminé.
Active count 1
Active count 1
wait :
size : 0
actifs : 1
TroisiemeProcess démarrer.
TroisiemeProcess essais : 4

SecondProcess FINISH

tentative 9 de 13
tentative 0 de 4
...
TroisiemeProcess termine apres 1185284414746 ms
TroisiemeProcess terminé.
Active count 1
wait :
size : 0
actifs : 1
TroisiemeProcess FINISH

tentative 11 de 13
tentative 12 de 13
PremierProcess termine apres 1185284414746 ms
PremierProcess terminé.
Active count 0
wait :
size : 0
actifs : 0
PremierProcess FINISH

Bien que l'on voit le message du listener signalant que le process est démarré, rien ne se passe tant qu'il n'y à pas 3 process ajoutés.

Voici le code run() d'un Process :

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
 public void run() {
 
        //System.out.println(name + " START ");
        fireConverterStarted();
        int essais = (int) ((Math.random()*10)*2);
 
        System.out.println(name + " essais : " + essais);
        JFrame frm = new JFrame("Tentative");
        frm.setLocationByPlatform(true);
        frm.setSize(100,200);
        frm.setVisible(true);
 
        for (int i=0; i<essais; i++) {
            System.out.println("\t tentative " + i + " de " + essais);
            frm.getContentPane().removeAll();
            frm.getContentPane().add(new JLabel("Tentative " + i + " de " + essais));
            frm.validate();
            try {
                new Socket("nonhost", 9999);
 
            } catch ( Exception e) {}
        }
        frm.setVisible(false);
 
        fireConverterFinished();
        frm.dispose();
        System.out.println(name + " FINISH ");

Merci

[coco62]

Il me semble que le jdk 1.5 propose avec les nouvelles API concurrent ce type de fonctionnement
http://java.sun.com/j2se/1.5.0/docs/...Executors.html

[Invité]

Oui il semble que cela puisse m'aider mais mon problème est sur un simple "exercice de style". J'aimerais donc trouver la cause du problème pour le plaisir de jouer avec les Threads.

Merci pour l'info, ça semble très intéressant.

[gifffftane]

Je ne peux pas expliquer précisement, mais je vois des maladresses qui rendent difficiles le suivi de ton code.

• Beaucoup de choses s'appellent run, ce qui fait qu'on ne sait plus très bien qui est quoi. Essaie de réserver le terme run à la méthode d'exécution d'un thread, ce qui rendra ton code plus intuitif pour nous, et pour moi, en particulier.
• Je ne suis pas sûr que les synchronisations soient bien faites, surtout si l'objet verrou est lui même un thread (puisqu'il comporte une méthode run...). J'avoue ne même pas savoir comment la JVM se débrouille dans ce cas là.
• Simplifie ton code au maximum lorsque tu galères pour le faire fonctionner, et évite les swing, surtout que à ce que je comprends tu ne fais pas gaffe à te caler sur l'Event Dispatching Thread pour lancer tes fenêtres, ce qui peut perturber tout le fonctionnement.

[Invité]

J'ai essayé d'utiliser un objet pour faire mes synchronisations mais j'ai une java.lang.IllegalMonitorStateException.

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
 
...
private Object verrou = new Object();
...
 public void run() {
        actif = true;
 
 
        while ( actif ) {
 
            if ( converters.size()>0 && getActiveCount()<MAX_CONVERTERS ) {
                try {
                    Converter converter = converters.getFirst();
                    new Thread(converter).start();
                    converters.removeFirst();
                } 
                catch ( NoSuchElementException e ) {}
            } 
            else {            
                try {
                    synchronized (verrou) {
                        System.out.println("wait : \n\t" + 
                                "size : " + converters.size() + "\n\t" +
                                "actifs : " + getActiveCount()
                                );
                        wait();                         
                    }
                }   
                catch ( InterruptedException e ) {
                    e.printStackTrace();
                    actif = false;
                }                
            }
        }
}
...

J'ai également commenté la partie Swing. Elle était la simplement pour avoir un meilleur aperçu de ce qui se passait.

[gifffftane]

J'ai l'impression qu'il te manque les bases élémentaires de manipulation des threads !

Si tu comprends l'anglais Lesson: Concurrency, sinon Les Threads multiples et plein d'autres.

Sinon il est utile d'indiquer la ligne où se produit l'erreur, je présume que la tienne vient d'un thread que tu relances, ou qui est en cours d'exécution, ou je ne sais quoi.