Discussion :

[chrisRg2r]

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

[chrisRg2r]

Je sais toujours pas pourquoi les dIBg s'accumulent. D'autre part je vais maximiser le heap size, mais étant donné que le programme est éventuellement destiné à être utilisé sur différentes machines, y'a-t-il un moyen de récupérer automatiquement le Xmx de la machine sur laquelle est installé le programme ?

[visiwi]

Salut,

J'ai pas trop lu ton problème parce qu'a c't'heure là j'peux plus ! Mais ...

Je ne sais pas trop si il est convenable d'appeler toi-même la méthode doInBackground() !

As-tu essayé de créer TA méthode. Et plutôt que d'appeler récursivement doInBackground() d'appeler récursivement TA méthode.

Si j'ai rien compris alors désolé

[chrisRg2r]

Salut,

D'abord merci de d'intéresser à mon problème.
J'ai effectivement esssayé de programmer une méthode récursive appelée une seule fois dans doInBackground(), mais le résultat est le même.
Par contre j'ai augmenté le heap size au maximum des capacités de mon PC (1024Mo pour une RAM de 2048) et le programme marche pour l'instant. Enfin je dis ça, je l'ai lancé il y a environ 3 heures en lui demandant la résolution de 210 polynômes du 19ème degré (je sais, j'suis pas normal) et il en est à peu près à 50 %. S'il en a encore pour 3 heures, je vais aller dormir ailleurs parce qu'il fait un bruit que j'avais encore jamais entendu. En tout cas les threads n'ont pas l'air de s'arrêter quand ils devraient, qu'on les programment dans doInBackground() ou dans une méthode séparée. T'as une idée ?

[visiwi]

Je n'ai pas vraiment d'idée pour régler ton problème. Mais dans un premier je chercherais à vérifier mon code métier sans Thread (ou SwingWorker) ni UI. Lorsque je serais certain de ce code, je chercherais à l'intégrer a un SwingWorker ou un Thread.
Bon courage !

[gifffftane]

Il n'est pas très facile de comprendre ton code. Par exemple, if (condition) ? ...et je n'ai trouvé condition déclarée ou renseigné nulle part. Etc dans le genre.

Je te conseille de revoir ton code en le rendant plus expressif. Cela t'aidera certainement à mieux maîtriser ce qu'il fait.