Discussion :

[manu11]

Bonjour,

Voilà j'ai un problème assez épineux que j'arrive pas à résoudre c'est ainsi que je demande votre aide.

Je suis en train de réaliser un projet j'ai presque terminé tous les traitements métier seul bémol c'est qu'après une grosse utilisation de mon appli j'ai des performances minable qui se termine par un out of memory, je vais essayer de vous explique le problème : je lis de gros fichier sur disque dur (pouvant atteindre jusqu’à 40000 lignes!!!) et je les insère dans ma BD appelons ce type de fichier TYPE A.

Ensuite je lis des fichier de TYPE B pouvons aller de 100 lignes jusqu'a 2000 que je dois insérer dans la BD mais en même temps en plus de cela chaque ligne d'un fichier de type B doit MAJ une ligne d'un fichier de TYPE A et c'est la d’où vient mon problème je doit charger tous les fichiers de type A pour effectuer les MAJ et en plus je dois insérer les lignes du fichier de type B.

Et avec tous ces objets qui restent dans la mémoire c'est normal qu'il y est des problèmes, la seule idée qui me vient en tête est après d'avoir commiter la transaction je libère totalement les objets de la mémoire mais je sais pas comment m'y prendre,si vous avez d'autre idée elles sont le bienvenue.

Cordialement.

[Rei Ichido]

Pour "libérer" un objet de la mémoire, il suffit qu'il ne soit plus référencé.

Tu pourrais nous montrer la partie concernée de ton code ?

[manu11]

OK voici le méthode en question:

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
 
    //permet de charger un retour quotidien vers un repertoire
    public boolean chargerRetourQuotidien(RetourQuotidien retourQuotidien,String repDest){
 
        Session currentSession = HibernateUtil.currentSession();
        Transaction tx = currentSession.beginTransaction();
 
        preparerStructureFichiersSorti(retourQuotidien,repDest);
        Set<DetailRetourQuotidien> details = retourQuotidien.getDetailRetourQuotidiens();
        Iterator<DetailRetourQuotidien> iter = details.iterator();
        DetailRetourQuotidien detailRetourQuotidien = new DetailRetourQuotidien();
        FichierEnvoiDAO fichierEnvoiDAO = new FichierEnvoiDAO();
        RetourQuotidienDAO retourQuotidien_DAO = new RetourQuotidienDAO();
        boolean anomalie = false;
        GestionFichierEnvoi gestionFichierEnvoi = new GestionFichierEnvoi();
        lstFichierEnvoiNonCloture = gestionFichierEnvoi.getLstFichierEnvoiNonCloture();
 
        DetailFichierEnvoi detailFichierEnvoi = null;
 
        HashMap<FichierEnvoi,ArrayList<Link_LigneDetailEnvoiPrLigneRetourQuotidien>>
                concordanceLigneRetQuEtLigneEnvoi = new HashMap<FichierEnvoi, ArrayList<Link_LigneDetailEnvoiPrLigneRetourQuotidien>>();
 
 
 
        while(iter.hasNext()){
            detailRetourQuotidien = iter.next();
            //System.out.println("retour-quotidien:"+detailRetourQuotidien.getCode_prestation()+ " " +detailRetourQuotidien.getNumFacture() + " "+detailRetourQuotidien.getRefFichier());
            FichierEnvoi fichierEnvoi = ifLigneRetourQuotidienAppartientA1FichierEnvoi(detailRetourQuotidien);
 
            if(fichierEnvoi!=null){
                //System.out.println("se trouve dans "+fichierEnvoi.getReferenceFichier());
                detailFichierEnvoi = getLigneDetailEnvoiPrLigneRetourQuotidien(fichierEnvoi,detailRetourQuotidien);
                //System.out.println("ligne:"+detailFichierEnvoi.getNumFacture());
                if(detailFichierEnvoi.getCode_statut_retour_impaye()==DetailFichierEnvoi.STATUT_RETOUR_IMPAYE_INSTANCE
                   &&
                   detailFichierEnvoi.getCode_statut_retour_paye()==DetailFichierEnvoi.STATUT_RETOUR_PAYE_INSTANCE)
                {                    
                    detailFichierEnvoi.setCode_statut_retour_paye(DetailFichierEnvoi.STATUT_RETOUR_PAYE_OK);
                    detailFichierEnvoi.setMontantRetour(detailRetourQuotidien.getMontantReglement());
                    fichierEnvoiDAO.updateFichierEnvoi(fichierEnvoi);
                    ajouterConcordance(concordanceLigneRetQuEtLigneEnvoi, fichierEnvoi, detailFichierEnvoi, detailRetourQuotidien);
                }
                else
                {
                    //Ecrire anomalie ligne déja regle
                    try {
                            FileWriter fw=new FileWriter(cheminRetourQuotidien+"\\Anomalies\\LigneDejaRegle.txt",true);
                            BufferedWriter bf= new BufferedWriter (fw);
                            bf.write(detailRetourQuotidien.getLigne()+"\r\n");
                            bf.close();
                    } catch (Exception e) {
                        System.out.println("ici "+ e.toString());
                    }
                    iter.remove();
                    retourQuotidien.getDetailRetourQuotidiens().remove(detailRetourQuotidien);
                    anomalie = true;
                }
            }
            else
            {
                //ecrire  anomalie fichier non charge
                try {
                        FileWriter fw=new FileWriter(cheminRetourQuotidien+"\\Anomalies\\LigneFichierInexistant.txt",true);
                        BufferedWriter bf= new BufferedWriter (fw);
                        bf.write(detailRetourQuotidien.getLigne()+"\r\n");
                        bf.close();
                } catch (Exception e) {
                    System.out.println("ici "+ e.toString());
                }
                iter.remove();
                retourQuotidien.getDetailRetourQuotidiens().remove(detailRetourQuotidien);
                anomalie = true;
            }
 
        }
 
        if(controlerUnicite(retourQuotidien.getDateRetour())==true)
            retourQuotidien_DAO.saveRetourQuotidien(retourQuotidien);
        else
            retourQuotidien_DAO.saveDetailRetourQuotidien(retourQuotidien);
 
 
        generationEncaissement(concordanceLigneRetQuEtLigneEnvoi);
 
        tx.commit();
        return anomalie;
    }

Au passage je voudrais savoir si le fait de fermer la session hibernate libère de la mémoire les objets de la session.

[Jimmy_]

Bonjour,

Tu as un soucis d'algorithme. Tu te mets dans une situation dangereuse dès que tu as du volume.

chaque ligne d'un fichier de type B doit MAJ une ligne d'un fichier de TYPE A et c'est la d’où vient mon problème je doit charger tous les fichiers de type A pour effectuer les MAJ et en plus je dois insérer les lignes du fichier de type B.

Si tu es obligés de travailler sur des fichiers il faut changer ça. Car il est normal d'obtenir des out of memory en chargeant trop de chose en mémoire.

Pour moi, il faut découper ton traitment en 2 : il faut produire un fichier intermédiaire de MAJ pour tes fichiers A. Et faire tes mises à jour ensuite. Au lieu de vouloir tout faire à fois :

1) Tu parcours B et tu produits un fichier de MAJ pour A.
2) Tu parcours A et ton fichier de MAJ en séquence et tu mets à jour si besoin.



Niveau perf les I/O sont forcement couteux, vu ton traitement les optimisations sont plus à faire au niveau de l'architecture de ton application.

[manu11]

Je suis pas dans la situation dans laquel tu parles Jimmy_ puisque les lignes des fichiers du type A ont déjà étés insérer dans la BD, je les lis pas du disque dur mais je les charge avec hibernate à partir de la BD.

[Jimmy_]

Ca revient au même si tu charges en mémoire toute ta base.

Découpe ton traitement en plusieurs étapes.