Mécanisme de gestion de la mémoire JNI et JNI

JNI (Java Native Interface) est un mécanisme fourni par Java pour appeler du code natif (C/C++) dans du code Java ou permettre au code natif d'appeler du code Java. JNI permet aux programmes Java d'interagir avec le code natif pour de meilleures performances ou un accès aux ressources système sous-jacentes.

À l'aide de JNI, vous pouvez déclarer une méthode native dans du code Java et l'associer à une implémentation native via une interface JNI. De cette façon, le code Java peut appeler la méthode locale via l'interface JNI et l'implémentation de la méthode locale peut être écrite en C/C++.

Voici les étapes générales pour utiliser JNI :

1. Écriture de code Java : déclarez les méthodes natives dans le code Java et nativemarquez-les avec des mots-clés. Par exemple:

   public class NativeExample {
       public native void nativeMethod();
   }

   2. Générez le fichier d'en-tête JNI : utilisez « javac » pour compiler le code Java, puis utilisez la commande « javah » pour générer le fichier d'en-tête JNI correspondant. Les fichiers d'en-tête JNI décrivent l'interface avec les méthodes natives. Par exemple:

   javac NativeExample.java
   javah NativeExample

   Cela générera un fichier d'en-tête nommé `NativeExample.h`.

   3. Écrire du code natif : implémentez la méthode native déclarée dans le fichier d'en-tête JNI en C/C++. Par exemple, utilisez C pour implémenter la méthode `nativeMethod` dans `NativeExample.h`.

   4. Compilez le code natif : compilez le code natif dans une bibliothèque partagée (bibliothèque de liens dynamiques) pour le chargement et l'appel par les programmes Java.

   5. Chargez la bibliothèque locale dans le code Java : utilisez la méthode `System.loadLibrary()` pour charger la bibliothèque native compilée. Par exemple, ajoutez le code suivant à votre code Java :

   ```java
   static {
       System.loadLibrary("native_example");
   }
   ```

   6. Appel de méthodes locales : appel de méthodes locales via du code Java. Par exemple:

   ```java
   NativeExample example = new NativeExample();
   example.nativeMethod();
   ```

   Lors de l'appel de `nativeMethod()`, JNI sera responsable du transfert du contrôle au code natif pour exécuter la fonction correspondante.

   Grâce à JNI, les programmes Java peuvent obtenir la possibilité d'interagir avec le code local, afin de pouvoir appeler des fonctions de bibliothèques locales, accéder aux ressources du système local ou améliorer les performances. Cependant, l'utilisation de JNI doit prendre en compte certains détails et considérations de bas niveau, tels que la gestion de la mémoire, la conversion de type, etc., il doit donc être utilisé et débogué avec soin.

Dans JNI, la gestion de la mémoire est un aspect important car Java et le code natif utilisent des modèles de gestion de la mémoire différents. Le JNI fournit des mécanismes pour gérer la mémoire et garantir une allocation et une désallocation correctes de la mémoire entre Java et le code natif.

Voici les mécanismes de gestion de mémoire couramment utilisés dans JNI :

1. NewObject, NewArray et NewString : JNI fournit des fonctions telles que `NewObject`, `NewArray` et `NewString`, qui sont utilisées pour allouer de la mémoire sur le tas Java en code natif. Ces fonctions renvoient une référence à la mémoire allouée, et il est de la responsabilité du développeur de libérer la mémoire lorsqu'elle n'est plus nécessaire.

2. DeleteLocalRef : Dans JNI, lorsque vous n'avez plus besoin d'utiliser une référence locale, vous pouvez utiliser la fonction `DeleteLocalRef` pour libérer manuellement la référence. Cela évite les fuites de mémoire causées par un trop grand nombre de références locales.

3. ReleasePrimitiveArrayElements et ReleaseStringUTFChars : lors de l'obtention du contenu de tableaux ou de chaînes dans le code local, JNI fournit les fonctions correspondantes, telles que `ReleasePrimitiveArrayElements` et `ReleaseStringUTFChars`. Ces fonctions sont utilisées pour libérer la mémoire obtenue via `GetPrimitiveArrayElements` et `GetStringUTFChars`, afin de garantir la libération correcte des ressources mémoire.

4. Référence globale et référence globale faible : La référence globale (Global Reference) et la référence globale faible (Weak Global Reference) dans JNI sont des mécanismes de gestion du cycle de vie des objets Java dans le code local. En créant une référence globale, vous pouvez transmettre une référence à un objet Java au code natif et garantir que la mémoire de l'objet sur le tas Java ne sera pas récupérée. L'utilisation de références globales faibles permet de récupérer les objets lorsqu'ils ne sont plus référencés par le code Java.

5. Gestion des exceptions : le mécanisme de gestion des exceptions dans JNI est cohérent avec Java. Lorsque le code natif génère une exception, JNI fournit une API pour obtenir des informations sur l'exception, lever une exception ou effacer l'état de l'exception.

Lorsque vous utilisez JNI pour la gestion de la mémoire, vous devez accorder une attention particulière aux éléments suivants :

- Évitez les fuites de mémoire : assurez-vous que les références locales sont libérées à temps lorsqu'elles ne sont plus utilisées, pour éviter les fuites de mémoire causées par un trop grand nombre de références locales.

- Évitez les références en suspens : étant donné que les objets Java peuvent être récupérés dans le code natif, il faut veiller à éviter de conserver trop longtemps les références d'objets Java dans le code natif afin d'éviter que des références en suspens ne se produisent.

- Gérer correctement les exceptions : lorsqu'une exception est levée dans le code local, vous devez utiliser l'API fournie par JNI pour gérer l'exception afin de garantir qu'elle peut être interceptée et gérée correctement.

En utilisant correctement le mécanisme de gestion de la mémoire fourni par JNI, vous pouvez garantir que l'allocation et la libération de la mémoire entre Java et le code natif sont effectuées correctement et éviter des problèmes tels que des fuites de mémoire et des références pendantes.