JNI -> Appeler méthode Java depuis C++ qui instancie un objet

Version imprimable

04/02/2015, 22h45
MilWolf

JNI -> Appeler méthode Java depuis C++ qui instancie un objet

Bonsoir à tous,

je me demandai si c'était correct avec de faire:

-appel d'une méthode C++ depuis Java en passant un objet en paramètre
-appel d'une méthode java de cet objet depuis la méthode C++, méthode qui instancie un objet

et l'appel de cette dernière méthode répété quelques millions de fois.

Je vous demande ça parce que j'ai l'impression que la mémoire de la JVM n'est pas libérée dans ce cas-là.
La mémoire du processus Java (visible depuis le moniteur) augmente lors de l'allocation mais qui ne diminue jamais, est-ce normal?

Merci pour vos réponses.
Bonne soirée.

MilWolf.
05/02/2015, 09h04
tchize_

Cet objet est retourné par la méthode java? si oui, quand tu n'utilise plus cet objet depuis la partie c++, tu dois mentionner à la JVM que tu ne l'utilise plus, car le garbage collector n'est capable d'analyser les référence que depuis le code java. Tout ce qui est créé pendant la partie native ou retourné à la partie native par un appel de méthode est maintenu comme une référence locale qui sera nettoyée uniquement à la fin de la méthode native. Si tu veux libérer au fur et à mesure, il faut collaborer et libérer explicitement les références dont tu n'a plus besoin. C'est expliqué ici:

http://journals.ecs.soton.ac.uk/java...ting/refs.html

Désolé, je n'ai pas trouvé de doc officielle chez oracle à ce sujet :)
06/02/2015, 19h42
MilWolf

Bonsoir,

Merci de ta réponse.
La méthode Java ne retourne pas l'objet en fait les objets créés sont ajoutés dans une collection de type FIFO et utilisés par un autre Runnable pour traitement.
Est-ce que je suis clair?
07/02/2015, 11h24
tchize_

Tu pourrais montrer ces méthode JNI? Aussi, si tous ces objets sont ajoutés à la FIFO mais que l'autre runnable ne les consomme pas, ta mémoire va effectivement augmenter. Ce n'est pas spécifique à JNI.

L'autre Runnable utilise la pile jusqu'à la vider mais la mémoire reste dans le processus.

Voici le Runnable qui appelle la méthode native:

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
 
 
public class Extraction implements Runnable{
 
    public final static Logger logger = Logger.getLogger(Extraction.class);
    private final EventListenerList listeners;
 
    private final BlockingQueue<Shot> arrayBlockingQueue;
    private final File file;
 
    private native boolean simpleExtraction(String file, Shots shots);
 
 
    public Extraction(File rxpFile, BlockingQueue<Shot> arrayBlockingQueue){
 
        listeners = new EventListenerList();
 
        this.arrayBlockingQueue = arrayBlockingQueue;
        this.file = file;
    }
 
    static {
        System.loadLibrary("RivLibJNI");
    }
 
    public void addExtractionListener(ExtractionListener listener){
        listeners.add(ExtractionListener.class, listener);
    }
 
    public void fireIsFinished(){
 
        for(ExtractionListener listener :listeners.getListeners(ExtractionListener.class)){
 
            listener.isFinished();
        }
    }
 
    @Override
    public void run() {
 
        Shots shots = new Shots();
 
        shots.addShotsListener(new ShotsListener() {
 
            @Override
            public void shotExtracted(Shot shot) {
                try {
                    arrayBlockingQueue.put(shot);
 
                } catch (InterruptedException ex) {
                    logger.error(ex);
                }
            }
        });
 
        boolean success = simpleExtraction(file.getAbsolutePath(), shots);
 
        fireIsFinished();
 
        if(!success){
            logger.error("extraction failed");
        }  
    }
 
}

Voici le Runnable qui traite les éléments de la pile:

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
 
public class VoxelAnalysis implements Runnable{
 
    private final static Logger logger = Logger.getLogger(VoxelAnalysis.class);
 
    private BlockingQueue<Shot> arrayBlockingQueue;
 
    private boolean isFinished;
 
    private final EventListenerList listeners;
 
    public void setIsFinished(boolean isFinished) {
        this.isFinished = isFinished;
    }
 
    public VoxelAnalysis(BlockingQueue<Shot> arrayBlockingQueue){
        this.arrayBlockingQueue = arrayBlockingQueue;
        listeners = new EventListenerList();
    }
 
 
    @Override
    public void run() {
 
        while(!isFinished || !arrayBlockingQueue.isEmpty()) {
 
            try {
                Shot shot = arrayBlockingQueue.take();
 
		//utilisation
 
            } catch (Exception e) {
                logger.error(e.getMessage());
            }
        }
 
        writer.close();
 
        } catch (IOException ex) {
 
        }        
 
        arrayBlockingQueue = null;
    }
}

La méthode native quand à elle ressemble à ça (je n'ai pas le code avec moi) :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
JNIEXPORT bool JNICALL
Java_simpleExtraction(JNIEnv *env, jobject obj, jstring filePath, jobject shots)
{
  jclass cls = env->GetObjectClass(shots);
  jmethodID mid = (*env)->GetMethodID(env, cls, "addShot", "(I)V");
 
  result = openConnection(filePath);
 
  while(result.hasNext()){
        env->CallVoidMethod(shots, mid, myparams);
  }
 
  return true;
 
}

Merci pour ton intérêt.