exécution de multiple SwingWorker simultanément

Bonjour,

Je cherche à exécuter plusieurs SwingWorker en parallèle. Je m'explique :

Dans mon application, l'utilisateur peut lancer un traitement relativement long mais qui n'est pas bloquant. Il peut donc le lancer et continuer à effectuer d'autres opérations. Cependant, ceci ne marche que sur le papier :?

Ce traitement est exécuté dans un SwingWorker qui va mettre à jour l'UI par le biais de la méthode done(), une fois doInBackground() terminée.

Durant ce traitement, l'utilisateur peut naviguer dans l'interface et ,imaginons, lancer une recherche dans la base de données. Cette recherche donne lieu à la création d'un autre SwingWorker qui va exécuter les différents traitements dans son doInBackground() et afficher les résultats dans une JTable par le biais de done().

Or, il apparaît que lorsqu'il démarre la recherche, le deuxième SwingWorker n'exécute sa méthode doInBackground() que lorsque que le premier a finit. Ce qui m'empêche de créer cette notion d'exécution en parallèle que je recherche.

J'ai lu que le thread pool de SwingWorker était limité à 10 SwingWorker, or dans l'état actuel de l'application seulement deux SW sont crées.
J'ai également lu que cela pourrait avoir un rapport avec le processeur de la machine. Si celui-ci est monocore, il ne peut lancer qu'un thread en background en plus du thread pour le GUI.

Quelqu'un pourrait-il infirmer ou affirmer ces informations ? Ou aurait-il de plus amples informations ?

Cordialement,

Salut,

Les SwingWorkers utilisent bien un pool de 10 threads par défaut.

Sur un processeur monocore les différentes tâches seront exécutées à tour de rôle. Le partage du processeur entre les deux dépendant du système hôte, de la JVM et de ton code.

Pour le reste il faudrait avoir une idée du code que tu exécutes en background (n'y aurait-il pas des méthodes synchronisées là derrière)

a++

Merci pour ta réponse.

Voici le code d'une de mes classe SW, elle effectue une opération d'update :

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
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
public class SWColTypeModify extends SwingWorker<HashMap, Object> implements Observable{
 
    public final static String STATE = "state";
    public final static String COMBO_CLONE = "comboClone";
    public final static String COMBO_SEARCH = "comboSearch";
 
    private Vector obs = ObserverVector.getInstance().getVector();
    private String name;
    private Integer rowId;
    private IndeterminateBar myBar;
 
    private ColumnTypeData ctData = new ColumnTypeData();
 
    public SWColTypeModify(String name, Integer id, IndeterminateBar bar) {
        this.name = name;
        this.rowId = id;
        this.myBar = bar;
    }
 
    @Override
    protected HashMap doInBackground() throws Exception {
 
        HashMap map = new HashMap(6);
 
        map.put(STATE, ctData.modifyRow(name, rowId));
        Vector vect = ctData.fillColumnTypeCombo();
        Vector vect2 = (Vector)vect.clone();
 
        map.put(COMBO_CLONE, vect);
        map.put(COMBO_SEARCH, vect2);
 
        return map;
    }
 
    @Override
    protected void done() {
        try {
 
            HashMap map = get();
 
            if ((Boolean) map.get(STATE))
            {
                TextAreaLog.getInstance().setText("Update Column Type '"+name+"' informations " +
                        "succeeded.\n");
                notifyObserver(map);
                myBar.finished();
            }
            else
            {
                TextAreaLog.getInstance().setText("Update Column Type '"+name+"' informations " +
                        "failed.\n");
                myBar.finished();
                notifyObserver(map);
            }
 
        } catch (InterruptedException ex) {
            Logger.getLogger(SWColTypeModify.class.getName()).log(Level.SEVERE, null, ex);
        } catch (ExecutionException ex) {
            Logger.getLogger(SWColTypeModify.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
 
    @Override
    public synchronized void addObserver(Observer o) {
        if(o == null)
            throw new NullPointerException();
        if(!obs.contains(o))
            obs.addElement(o);
    }
 
    @Override
    public synchronized void deleteObserver(Observer o) {
            obs.remove(o);
    }
 
    @Override
    public synchronized void deleteObservers() {
        obs.removeAllElements();
    }
 
    @Override
    public void notifyObserver(Object arg) {
        for (int i = obs.size()-1; i>=0; i--)
            ((Observer)obs.get(i)).update(this, arg);
    }
 
}

Il faut savoir que mes classes SW implémentent également l'interface Observable, qui correspond au pattern Observable/Observer. J'ai juste redéfini deux interfaces au lieu d'utiliser la classe Observable que met à disposition JAVA.

Et ensuite, j'ai externaliser le vecteur d'Observer dans un Singleton : ObserverVector dont voici le code :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class ObserverVector {
 
    private Vector obs = new Vector();
 
    public static ObserverVector singleton;
 
    private ObserverVector() {}
 
    public static synchronized ObserverVector getInstance() {
 
        if(singleton == null)
            singleton = new ObserverVector();
 
        return singleton;
    }
 
    /**
     * Returns the observer vector.
     * @return
     *      The vector containing all observers in the application.
     */
    public Vector getVector() { return this.obs; }
}

Je n'ai donc pas de méthodes synchronized dans mon doInBackground et la seule méthode synchronized est l'appel au singleton TextAreaLog qui est JTextArea que j'utilise pour afficher des messages de logs. Après au niveau des objets, les seuls objets synchronized sont les objets Vector, il me semble.

Je possède une classe SW pour chaque opération de delete, update, insert et select dans chaque module de mon application (~20 modules). Elles ont toutes la même organisation.

De plus, le SW qui exécute le traitement long ( appel de logiciels externes en ligne de commande et lancement de commande sur ces logiciels) implémente aussi Observable.

Je viens de tester en remplaçant cette classe SW par une classe héritant de Thread et en mettant le traitement de doInBackground dans la méthode run() et le traitement de done() dans un SwingUtilities.invokeLater(). Apparemment, ça n'a plus le même effet bloquant qu'avec la classe SW.
J'avoue que je ne comprend pas ... SW n'est-elle pas sensée créer un thread à part pour exécuter doInBackground() ? Ou alors est-ce qu'il y a des blocages natifs inter-SW ?