Pb pour liberer les ressources

Version imprimable

Bonjour,

comme dit dans le titre je cherche à supprimer un fichier précédemment
chargé dans un byteBuffer.

J'utilise l'API PDF Renderer qui nécessite de charger le fichier dans un byteBuffer mais impossible de libérer la ressource ensuite

Voila un exemple de 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
24
25
26
27
 
import java.io.File;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
 
public class Main
{
    public static void main(String[] args)
    {
        RandomAccessFile raf = null ; FileChannel channel = null;  ByteBuffer buf = null;
 
            try {
            raf = new RandomAccessFile(new File("c:/azerty.pdf"), "r");
            channel = raf.getChannel();
            buf = channel.map(FileChannel.MapMode.READ_ONLY, 0, channel.size());
 
            raf.close();
            channel.close();
            System.out.println(buf.hasRemaining());
        } catch (Exception e) {
        }
 
        boolean a = new File("c:/azerty.pdf").delete();
        System.out.println(a);
    }
}

J'ai essayé buf = null;, buf.rewind();, buf.remaining(); mais aucun ne fait effet
Si je supprime la ligne :

Code:

1
2
 
buf = channel.map(FileChannel.MapMode.READ_ONLY, 0, channel.size());

le fichier se supprime

Une Idée ???

29/07/2010, 02h36
tchize_

Code:

new File("c:/azerty.pdf").delete();

par exemple.

Si tu supprime la ligne, je crois surtout que le fichier ne se crée pas, pas qu'il se supprimer ;)

PS: retirer ce catch Exception, c'est mauvais pour tout un tas de raison (capture trop large, pas de gestion dans le catch, disparition des messages d'erreur)

Merci de me répondre comme à chaque fois

J'ai modifié le code qui est en fait un code test pour savoir la ou ca bloque quand je veux supprimer le fichier
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 public class Main { public static void main(String[] args) { try { File fichier = new File("c:/azerty.pdf"); RandomAccessFile raf = new RandomAccessFile(fichier, "r"); FileChannel channel = raf.getChannel(); ByteBuffer buf = channel.map(FileChannel.MapMode.READ_ONLY, 0, channel.size()); raf.close(); channel.close(); buf.clear(); boolean a = fichier.delete(); System.out.println(a); File fichier2 = new File("c:/azerty2.pdf"); RandomAccessFile raf2 = new RandomAccessFile(fichier2, "r"); FileChannel channel2 = raf2.getChannel(); buf = channel2.map(FileChannel.MapMode.READ_ONLY, 0, channel2.size()); System.gc(); a = fichier.delete(); System.out.println(a); } catch (IOException ex) { Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex); } } }
Apparemment le pb se situe au niveau de byteBuffer. Je n'arrive pas à libérer la ressource, donc pas à supprimer mon fichier. Si je charge un autre fichier dans le byteBuffer et si et seulement si je lance le garbage collector manuellement, il me le supprime.

Comment faire pour libérer proprement un byteBuffer?

29/07/2010, 10h24
thelvin

D'après la JavaDoc de FileChannel.map(), on ne peut pas libérer proprement un ByteBuffer obtenu avec. Il sera libéré quand il sera garbage-collecté.
Une histoire de spécificité des OS, si j'ai bien compris.

J'ai bien peur qu'il ne reste qu'à essayer, genre toutes les minutes, de supprimer le fichier mappé, jusqu'à ce que ça marche. Un peu ch*ant je le reconnais, mais en implémentant un service qui se charge de gérer tout ça, c'est jouable.
29/07/2010, 11h11
snay13

Ok je te remercie pour ta réponse

C'était ce que j'avais vu que l'on ne pouvait pas libérer proprement un byteBuffer.

Par contre je ne vois pas trop comment je pourrais réaliser un service s'occuppant de ça.

Est ce que je dois charger un autre fichier dans le byteBuffer?
Créer un timer?

Si tu as un bout de code ou un exemple pour l'implémenter, javoue que la je suis un peu perdu.
:calim2:
29/07/2010, 13h37
thelvin

Euh, un bout de code, non.

Il s'agit de programmer un objet singleton dont on peut appeler une méthode void deleteWhenReleased(File), ce qui pousse cet objet à ajouter le fichier dans sa liste de fichier à supprimer. Cet objet a aussi son propre thread, qui passe son temps à attendre qu'un Timer, toutes les minutes, se déclenche, et à ce moment-là il essaie de supprimer tous les fichiers qu'il doit supprimer, et "oublie" ceux qu'il est enfin parvenu à supprimer.
C'est assez simple, il faut juste faire attention à bien synchroniser le thread du timer avec les threads appelant deleteWhenReleased().
29/07/2010, 15h16
snay13

Je vais regarder de plus près ce que tu me propose mais je ne pense pas que cela corresponde à mes besoins pour mon appli car j'ai une jtables avec un ecouteur qui relate en temps reel les changements effectués dans ce dossier.

Il faut donc que j'arrive à libérer les ressources au moment ou l'utilisateur supprime ce fichier
29/07/2010, 15h24
thelvin

Citation:

Envoyé par snay13

Il faut donc que j'arrive à libérer les ressources au moment ou l'utilisateur supprime ce fichier

? Je ne vois pas d'où vient cette conclusion.

Si ça doit être supprimé un peu plus "en temps réél", tu n'as qu'à vérifier toutes les secondes au lieu de toutes les minutes. En général les gros objets sont garbage-collectés presque aussi tôt que possible.

Bon, sinon il reste la solution, assez sale mais efficace, de charger tout le fichier dans un ByteBuffer, mais pas en le mappant, non, simplement en le copiant du disque vers la mémoire.

Salut,

Tout d'abord quelques remarques, même si c'est juste un bout de code jeté comme cela :

La déclaration/initialisation à null de toutes les variables en début de code... ca fait très "C" :?
Le catch() vide est particulièrement affreux !
Il manque les try/finally pour les libérations...

Sinon pour en revenir au sujet, ce bug est connu et existe depuis très longtemps : http://bugs.sun.com/bugdatabase/view...bug_id=4724038

Apparemment le fait de libérer le mapping "comme ça" cela pourrait entrainer des problèmes dans un environnement multithreadé, et l'implémentation d'une solution alternative serait énormément couteuse...

Du coup le buffer est libéré seulement lors du passage du GC...

Il est possible de forcer la libération en appelant explicitement la méthode de libération via l'API de reflection :
Code:

1 2 3 4 5 6 7 8 9 10 11 public static void unmap(MappedByteBuffer buffer) throws IOException { try { Method cleanerMethod = buffer.getClass().getMethod("cleaner"); cleanerMethod.setAccessible(true); Object cleanerObject = cleanerMethod.invoke(buffer); cleanerObject.getClass().getMethod("clean").invoke(cleanerObject); } catch (Exception e) { throw new IOException("Unable to unmap buffer", e); } }
Toutefois il y a plusieurs contraintes :

Cela nécessite certains droits propre à la reflection et à setAccessible(), ce que pourrait bloquer un SecurityManager (par exemple il est impossible de faire cela dans une appli JWS non-signé)
C'est spécifique à l'implémentation interne de la JVM de Sun. Rien ne garantie que cela fonctionnera sur d'autres JVM...
Rien ne garantie non plus que cela fonctionnera dans les futures JVM de Sun/Oracle...
Tu pourrais rencontrer les problèmes cité dans le bug en cas d'utilisation multithreadé.

a++

[EDIT] PS : Au fait, tu en fait quoi exactement de ce MappedByteBuffer ???

Merci pour vos reponses, je vais etudier cela tout de suite.

Pour revenir au byteBuffer, il utiliser par l'API PDF Renderer
voila la classe que j'aifaite pour manipuler l'API en m'appuyant sur les exemples du site

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
 
package apptekprod2;
 
import com.sun.pdfview.*;
import java.io.*;
import java.nio.channels.FileChannel;
import java.nio.ByteBuffer;
import java.util.logging.Level;
import java.util.logging.Logger;
 
/**
 * Class gerant l'affichage et la manipulation des fichiers PDF
 * API PDF Renderer
 * @author albertini
 */
public class ManagerPdf extends PagePanel
{
    private File fichierPDF;
    private RandomAccessFile raf; private FileChannel channel;
    private ByteBuffer buf; private PDFPage page; private PDFFile pdffile;
    private int nbPagePdf = 1, numPagePdf = 1;
 
    public ManagerPdf()
    {
        super(); 
    }
    /**
     * Selection du fichier PDF
     * @param fichierPdf (File)
     */
    public void setFichierPdf(File fichierPdf)
    {
        this.fichierPDF = fichierPdf;
        try
        {
            raf = new RandomAccessFile(fichierPDF,"r");
            channel = raf.getChannel();
            //buf = channel.map(FileChannel.MapMode.READ_ONLY,0, channel.size());
            pdffile = new PDFFile(channel.map(FileChannel.MapMode.READ_ONLY,0, channel.size()));
            nbPagePdf = pdffile.getNumPages();
        }    
 
        catch (IOException e) { e.printStackTrace();}
    }
    /**
     * Selection de la page du fichier PDF
     * @param numPagePdf (int)
     */
    public void setPagePdf(int numPagePdf)
    {
        this.numPagePdf = numPagePdf;
        page = pdffile.getPage(numPagePdf);
        //showPage(pdffile.getPage(numPagePdf));
        showPage(page); 
        waitForCurrentPage();
    }
    /**
     * Fermeture du fichier PDF en cours
     */
    public void setClosePdf()
    {
        try     {   raf.close(); channel.close(); pdffile = null;   }
        catch (IOException ex)    { ex.printStackTrace(); }
    }
    /**
     * Retourne le fichier PDF
     * @return File
     */
    public File getFichierPdf()                     {   return fichierPDF;  }
    /**
     * Retourne la page courante du fichier PDF
     * @return int
     */
    public int getCurrentPagePdf()                  {   return numPagePdf;  }
    /**
     * Retourne le nombre de page du fichier PDF
     * @return int
     */
    public int getNbPagePdf()                       {   return nbPagePdf;   }
}

Ma classe est loin d'être parfaite, je débute :oops:

Si vous avez des optimisations, je suis preneur

Je reviens vers vous après avoir essayé ces méthodes

29/07/2010, 18h37
tchize_

je me demande quel est le génie qui a eu la bonne idée créer une api d'affichage nécessitant qu'on passe les fichiers sous forme de bytebuffer plutot que de suivre l'api outputstream. C'est pas comme si, en général, un PDF ça occupait 15G sur le disque :aie:

Pour ton cas, est-ce que le fichier s'efface quand tu active file.deleteOnExit() et que tu quitte la jvm?

J'ai essayé aussi la methode deleteOnExit qui n'a donné aucun resultat

Entre temps j'ai pu faire quelque test :

La Methode :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
    public static void unmap(MappedByteBuffer buffer) throws IOException {
		try {
			Method cleanerMethod = buffer.getClass().getMethod("cleaner");
			cleanerMethod.setAccessible(true);
			Object cleanerObject = cleanerMethod.invoke(buffer);
 
			cleanerObject.getClass().getMethod("clean").invoke(cleanerObject);
		} catch (Exception e) {
			throw new IOException("Unable to unmap buffer", e);
		}
	}

me fait planter l'appli des que je selectionne un fichier

Par contre, j'ai un petit peu avancer entre temps, j'ai intégrer des try finally
et pu contourner le problème du byteBuffer en ne créant pas d'instance
Maintenant je bloque au niveau de la liberation de pdfPage une classe de pdfRenderer.

je redonne mon code modifié

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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
 
import com.sun.pdfview.*;
import java.io.*;
import java.lang.reflect.Method;
import java.nio.channels.FileChannel;
import java.nio.ByteBuffer;
import java.nio.MappedByteBuffer;
 
/**
 * Class gerant l'affichage et la manipulation des fichiers PDF
 * API PDF Renderer
 * @author albertini
 */
public class ManagerPdf extends PagePanel
{
    private File fichierPDF;
    private RandomAccessFile raf; private FileChannel channel;
    private ByteBuffer buf; private PDFPage page; private PDFFile pdffile;
    private int nbPagePdf = 1, numPagePdf = 1;
 
    public ManagerPdf()
    {
        super(); 
    }
    /**
     * Selection du fichier PDF
     * @param fichierPdf (File)
     */
    public void setFichierPdf(File fichierPdf)
    {
        this.fichierPDF = fichierPdf;
        try
        {
            try
            {
                raf = new RandomAccessFile(fichierPDF,"r");
                channel = raf.getChannel();
                //buf = channel.map(FileChannel.MapMode.READ_ONLY,0, channel.size());
                //pdffile = new PDFFile(buf);
                pdffile = new PDFFile(channel.map(FileChannel.MapMode.READ_ONLY,0, channel.size()));
                nbPagePdf = pdffile.getNumPages();
            }
            finally
            {
                raf.close(); channel.close();// unmap((MappedByteBuffer) buf);
            }
        }
        catch (IOException e)   {   e.printStackTrace();    }
    }
    /**
     * Selection de la page du fichier PDF
     * @param numPagePdf (int)
     */
    public void setPagePdf(int numPagePdf)
    {
        this.numPagePdf = numPagePdf;
        page = pdffile.getPage(numPagePdf);
        //showPage(pdffile.getPage(numPagePdf));
        //showPage(page);
        //waitForCurrentPage();
    }
    /**
     * Fermeture du fichier PDF en cours
     */
    public void setClosePdf()
    {
 
        pdffile = null; System.gc();
        /*try     {   raf.close(); channel.close(); pdffile = null;
        Outil.unmap(page);  }
        catch (IOException ex)    { ex.printStackTrace(); }*/
    }
    /**
     * Retourne le fichier PDF
     * @return File
     */
    public File getFichierPdf()                     {   return fichierPDF;  }
    /**
     * Retourne la page courante du fichier PDF
     * @return int
     */
    public int getCurrentPagePdf()                  {   return numPagePdf;  }
    /**
     * Retourne le nombre de page du fichier PDF
     * @return int
     */
    public int getNbPagePdf()                       {   return nbPagePdf;   }
    /**
     * Liberer un byteBuffer
     */
    public static void unmap(MappedByteBuffer buffer) throws IOException {
		try {
			Method cleanerMethod = buffer.getClass().getMethod("cleaner");
			cleanerMethod.setAccessible(true);
			Object cleanerObject = cleanerMethod.invoke(buffer);
 
			cleanerObject.getClass().getMethod("clean").invoke(cleanerObject);
		} catch (Exception e) {
			throw new IOException("Unable to unmap buffer", e);
		}
	}
}

Si je n'apelle pas la methode setPagePdf dans mon appli
et que
pdf.setClosePdf()
file.delete()
ca fonctionne

:lahola:

Voila Probleme Résolu :
Je mets ma classe en pensant que cela pourra servir à quelqu'un d'autre

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
 
import com.sun.pdfview.*;
import java.io.*;
import java.nio.channels.FileChannel;
 
/**
 * Class gerant l'affichage et la manipulation des fichiers PDF
 * API PDF Renderer
 * @author albertini
 */
public class ManagerPdf extends PagePanel
{
    private File fichierPDF; private int nbPagePdf = 1, numPagePdf = 1;
    private RandomAccessFile raf; private FileChannel channel;
    private PDFFile pdffile;
 
    public ManagerPdf()
    {
        super(); setBounds(835, 125, 355, 455);
    }
    /**
     * Selection du fichier PDF
     * @param fichierPdf (File)
     */
    public void setFichierPdf(File fichierPdf)
    {
        this.fichierPDF = fichierPdf;
        try
        {
            try
            {
                raf = new RandomAccessFile(fichierPDF,"r");
                channel = raf.getChannel();
                pdffile = new PDFFile(channel.map(FileChannel.MapMode.READ_ONLY,0, channel.size()));
                nbPagePdf = pdffile.getNumPages();
            }
            finally
            {
                raf.close(); channel.close();
            }
        }
        catch (IOException e)   {   e.printStackTrace();    }
    }
    /**
     * Selection de la page du fichier PDF
     * @param numPagePdf (int)
     */
    public void setPagePdf(int numPagePdf)
    {
        this.numPagePdf = numPagePdf;
        showPage(pdffile.getPage(numPagePdf)); waitForCurrentPage();
    }
    /**
     * Fermeture du fichier PDF en cours
     */
    public void setClosePdf()                       
    {   pdffile = null; showPage(null); System.gc();    }
    /**
     * Retourne le fichier PDF
     * @return File
     */
    public File getFichierPdf()                     {   return fichierPDF;  }
    /**
     * Retourne la page courante du fichier PDF
     * @return int
     */
    public int getCurrentPagePdf()                  {   return numPagePdf;  }
    /**
     * Retourne le nombre de page du fichier PDF
     * @return int
     */
    public int getNbPagePdf()                       {   return nbPagePdf;   }
}

Si vous avez des optimisations je suis preneur

Merci à tous ceux qui ont participé à ce Post :ccool:

30/07/2010, 08h44
adiGuba
- Les try/finally sont incorrect : il devrait y en avoir un par ressource, et l'ouverture de la ressource doit se situer AVANT le try
  Comment libérer proprement les ressources (ou comment utiliser proprement les bloc try/finally) ?
- Le RandomAccessFile et le FileChannel sont utilisés comme des variables locales, alors pourquoi les déclarer comme attributs d'instance ???
a++

ok merci pour les conseils

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
    public void setFichierPdf(File fichierPdf)
    {
        this.fichierPDF = fichierPdf;
        RandomAccessFile raf = null; FileChannel channel = null;
        try
        {
            try
            {
                raf = new RandomAccessFile(fichierPDF,"r");
                try
                {   
                    channel = raf.getChannel();
                    pdffile = new PDFFile(channel.map(FileChannel.MapMode.READ_ONLY,0, channel.size()));
                    nbPagePdf = pdffile.getNumPages();
                }
                finally     {   raf.close();    }
            }
            finally   {     channel.close();    }
        }
        catch (IOException e)   {   e.printStackTrace();    }
    }