Discussion :

[irnbru]

Hello à tous ! J'ai besoin de savoir comment vous procéder pour faire le besoin suivant:
- un client quelconque (console, swing, autre)
- une bibliothèque lancant une opération longue
- la bibliothèque doit informer le client de l'avancement (exprimé en % 0 à 100)
- le client affiche la progression ex: 22%, 29%

J'ai pensé à générer un thread pour l'opération longue afin de libérer le client de toute attente, puis de créer une sorte de callback où le thread informe la client de l'avancement de la longue opération

Merci
IRNBRU

[sinok]

Grosso modo il te faut un mécanisme permettant au thread de signifier qu'il a fini son exécution, un système à base d'observer/observable.

Ou sinon tu peux également t'inspirer de ce qui est fait dans la classe SwingWorker (sauf que celle ci est entièrement spécifique à Swing avecv la gestion de l'EDT inclue).

[irnbru]

Merci sinok pour l'aide j'ai pensé à faire une interface

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
 
package com.irnbru;
 
public interface IEvent {
    void stuff(int i);
}
 
 
puis à faire
 
package com.irnbru;
 
public class Worker implements Runnable {
 
    public int i;
    private IEvent ie;
 
    public Worker(IEvent ie){
        this.ie = ie;
    }
 
    @Override
    public void run() {
        // TODO Auto-generated method stub
        for(int j=0; j < 1000; j++){
            i = j;
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            if(j%10==0){
                ie.stuff(j);
            }
        }
    }
 
}
 
Enfin 
 
public class ProgramTest implements IEvent {
 
    public static void main(String[] args){
 
        Worker oWorker = new Worker(new ProgramTest ());
 
        Thread t = new Thread(oWorker);
        t.start();
    }
    @Override
    public void stuff(int i) {
        System.out.println("ok " + i);
 
    }
}

Qu'en penses tu? Sachant que je n'ai besoin que d'un seul observateur pour le moment.

Cheers
IRNBRU

[sinok]

Tu ne perds rien à stocker une liste d'observer, ça marchera pour un seul aussi. Et éventuellement prévoir plusieurs types de notification genre progression/fin. Car certains observers seront uniquement intéressés par une fin de tâche tandis que d'autres par la progression (la barre de progression sera intéressée par les deux, tandis qu'un code métier n'aura besoin que de la notification de fin par exemple). Et comment fais tu si tu as une tâche de durée indéterminée, ou alors une tâche avec des étapes dont tu ne connais pas la durée?

[irnbru]

Merci pour tes pistes Sinok, donc si je comprends bien, malgré mes limitations de mon code ne prennant pas en compte tous les cas possibles, mon code va sur la bonne piste quand même? A savoir utiliser un thread (avec l'interface runnable) et une implémentation simplifiée du design pattern observer pour informer le client de l'avancement du thread dans sa tâche est-il correct?

Cheers,
IRNBRU

[sinok]

Ca me semble relativement correct comme utilisation.

Toutefois vu que tu vas bosser en environnement multithread il serait pas mal que tu lises l'article suivant afin de pouvoir être sûr que le patter s'appllique de façon correcte.
http://www.javaworld.com/jw-03-1999/jw-03-toolbox.html

[irnbru]

Merci bcp sinok pour ton avis, ton lien (que j'ai déjà vu avant et parait encore d'actualité malgré 10 ans d'âge) et ton appréciation prudente de mon code

j'ai trouvé un autre exemple de ce que je veux faire et cela colle exactement à mon code la différence mineure (dans mon cas en tout cas car pas besoin) est la présence d'un Set pour garder tous les observers. (ajout, enlevement)

Je met le code pour les autres intéressés et il y en aura c'est sur
IRNBRU

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
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
 
package com.geekcap.designpatterns.observer;
 
public interface TrafficLightObserver {
    public void greenLight();
    public void yellowLight();
    public void redLight();
}
 
package com.geekcap.designpatterns.observer;
 
public class Car implements TrafficLightObserver {
    private String name;
 
    public Car( String name ) {
        this.name = name;
    }
 
    public void greenLight() {
        System.out.println( name + ": green light = go" );
    }
    public void yellowLight() {
        System.out.println( name + ": yellow light = slow down" );
    }
    public void redLight() {
        System.out.println( name + ": red light = stop" );
    }
}
 
package com.geekcap.designpatterns.observer;
 
import java.util.Set;
import java.util.HashSet;
 
public class TrafficLight implements Runnable {
    private Set<TrafficLightObserver> observers = new HashSet<TrafficLightObserver>();
    private enum STATE { GREEN, YELLOW, RED };
    private boolean running = false;
    private Thread thread = new Thread( this );
 
    public void run() {
        // Initialize the state of the light
        STATE state = STATE.GREEN;
 
        // Initialize the running state
        running = true;
 
        while( running ) {
            if( state == STATE.GREEN ) {
                fireGreenLight();
                state = STATE.YELLOW;
            }
            else if( state == STATE.YELLOW ) {
                fireYellowLight();
                state = STATE.RED;
            }
            else {
                fireRedLight();
                state = STATE.GREEN;
            }
 
            try {
                Thread.sleep( 2000 );
            }
            catch( Exception e ) {
            }
        }
   }
 
    public void start() {
        thread.start();
    }
 
    public void stop() {
        running = false;
    }
 
 
    public void addTrafficLightObserver( TrafficLightObserver observer ) {
        observers.add( observer );
    }
 
    public void removeTrafficLightObserver( TrafficLightObserver observer ) {
        observers.remove( observer );
    }
 
    private void fireRedLight() {
        for( TrafficLightObserver observer : observers ) {
            observer.redLight();
        }
    }
 
    private void fireGreenLight() {
        for( TrafficLightObserver observer : observers ) {
            observer.greenLight();
        }
    }
 
    private void fireYellowLight() {
        for( TrafficLightObserver observer : observers ) {
            observer.yellowLight();
        }
    }
 
    public static void main( String[] args ) {
        Car porsche = new Car( "Porsche" );
        Car civic = new Car( "Civic" );
        TrafficLight light = new TrafficLight();
        light.addTrafficLightObserver( porsche );
        light.addTrafficLightObserver( civic );
        light.start();
        try {
            Thread.sleep( 20000 );
        }
        catch( Exception e ) {
        }
        light.stop();
    }
}