Bonjour,

J'utilise un SwingWorker pour effectuer un calcul qui peut être très long, ce calcul étant effectué de manière récursive dans la méthode doInBackground, qui est donc elle-même récursive. Voici la structure du code :

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
package PE;
import java.beans.*;
import javax.lang.model.type.NullType;
import javax.swing.SwingWorker;
 
public class Class4 extends SwingWorker<NullType,Integer> {
 
    private static int[] A;
    protected static boolean F = false;
    protected static boolean G = true;
 
    protected Class4(int[] a) {
        A = a;
        addPropertyChangeListener(new PropertyChangeListener() {
            @Override
            public void propertyChange(PropertyChangeEvent H) {
                if (getProgress() == 100 || Class3.I.isDone()) {
// actions
                    if (getProgress() == 100) {
                        F = true;
                    }
                }
                if (F) {
                    Class3.H.setText("100 %");
                }
                else {
                    Class3.H.setText(String.valueOf(getProgress())+" %");
                }
            }
        });
    }
 
    @Override
    protected NullType doInBackground() {
        if (this.isCancelled()) {
            new Class7(A[2],A[5],true);
        }
        else {
//actions
            for (int i=0;i<A[5]-A[2];i++) {
                for (int j=0;j<A[5]-A[2];j++) {
                    if (this.isCancelled()) {
                        j = A[5]-A[2];
                        i = A[5]-A[2];
                    }
                    else {
                        if (condition) {
//actions
                            setProgress((int) progress);
                            publish(getProgress());
                        }
                        else {
                            j = A[5]-A[2];
                            i = A[5]-A[2];
//modification des paramètres
                            doInBackground();
                        }
                    }
                }
            }
        }
        if (this.isDone() == false && G) {
            G = false;
// terminaison du calcul
        }
        return null;
    }
 
}
Ce code marche bien, même pour un calcul relativement long, mais s'il est très long, il s'arrête au bout d'un certain nombre d'appels à doInBackground(). J'observe par ailleurs un ralentissement du calcul au bout d'un certain nombre de récursions. Lorsque le calcul n'est pas trop long mais que doInBackground() est quand même rappelée un certain nombre de fois, donc quand condition == false, je dois de plus utiliser deux booléens F et G qui n'ont normalement pas lieu d'être :
- F sert à ce que l'affichage reste à 100 % lorque le calcul est terminé car sinon il redescend à une valeur inférieure
- G sert à ce que la terminaison du calcul ne s'effectue qu'une seule fois car sinon j'observe qu'elle est effectuée plusieurs fois

Je pense donc que le n-ième doInBackground() ne s'arrête pas lorsque le (n+1)-ième est lancé, et ce jusqu'à planter le programme s'il y en a trop qui s'exécutent en même temps. Si une âme charitable voit un moyen de résoudre ce problème, je suis preneur.

Merci d'avance