| Java Native Interface Programming

## Local and Global References

> So far, we have used data types such as `jobject`, `jclass`, and `jstring` to denote references to Java objects. The JNI creates references for all object arguments passed in to native methods, as well as all objects returned from JNI functions.

> These references will keep the Java objects from being garbage collected. To make sure that Java objects can eventually be freed, the JNI by default creates local references. Local references become invalid when the execution returns from the native method in which the local reference is created. Therefore, a native method must not store away a local reference and expect to reuse it in subsequent invocations.

> For example, the following program (a variation of the native method in `FieldAccess.c`) mistakenly caches the Java class for the field ID so that it does not have to repeatedly search for the field ID based on the field name and signature:

>     /* This code is illegal */
>     static jclass cls = 0;
>     static jfieldID fld;

>     JNIEXPORT void JNICALL
>     Java_FieldAccess_accessFields(JNIEnv *env, jobject obj)
>     {
>       ...
>       if (cls == 0) {
>         cls = (*env)->GetObjectClass(env, obj);
>         if (cls == 0)
>           ... /* error */
>         fid = (*env)->GetStaticFieldID(env, cls, "si", "I");
>       }
>       ... /* access the field using cls and fid */
>     }

> This program is illegal because the local reference returned from `GetObjectClass` is only valid before the native method returns. When `Java_FieldAccess_accessField` is entered the second time, an invalid local reference will be used. This leads to wrong results or to a VM crash.

> To overcome this problem, you need to create a global reference. This global reference will remain valid until it is explicitly freed:

>     /* This code is OK */
>     static jclass cls = 0;
>     static jfieldID fld;

>     JNIEXPORT void JNICALL
>     Java_FieldAccess_accessFields(JNIEnv *env, jobject obj)
>     {
>       ...
>       if (cls == 0) {
>         jclass cls1 = (*env)->GetObjectClass(env, obj);
>         if (cls1 == 0)
>           ... /* error */
>         cls = (*env)->NewGlobalRef(env, cls1);
>         if (cls == 0)
>           ... /* error */
>         fid = (*env)->GetStaticFieldID(env, cls, "si", "I");
>       }
>       ... /* access the field using cls and fid */
>     }

> A global reference keeps the Java class from begin unloaded, and therefore also ensures that the field ID remains valid, as discussed in Accessing Java Fields. The native code must call `DeleteGlobalRefs` when it no longer needs access to the global reference; otherwise, the corresponding Java object (e.g., the Java class referenced to by `cls` above) will never be unloaded.

> In most cases, the native programmer should rely on the VM to free all local references after the native method returns. In certain situations, however, the native code may need to call the `DeleteLocalRef` function to explicitly delete a local reference. These situations are:

> - You may know that you are holding the only reference to a large Java object, and you do not want to wait until the current native method returns before the Java object can be reclaimed by the garbage collector. For example, in the following program segment, the garbage collector may be able to free the Java object referred to by `lref` when it is running inside `lengthyComputation`:

>         lref = ...            /* a large Java object */

>         ...                   /* last use of lref */
>         (*env)->DeleteLocalRef(env, lref);

>         lengthyComputation(); /* may take some time */

>         return;               /* all local refs will now be freed */
>       }

> - You may need to create a large number of local references in a single native method invocation. This may result in an overflow of the internal JNI local reference table. It is a good idea to delete those local references that will not be needed. For example, in the following program segment, the native code iterates through a potentially large array `arr` consisting of java strings. After each iteration, the local reference to the string element can be freed:

>         for(i = 0; i < len; i++) {
>           jstring jstr = (*env)->GetObjectArrayElement(env, arr, i);
>           ...                                /* processes jstr */
>           (*env)->DeleteLocalRef(env, jstr); /* no longer needs jstr */
>         }

| Java Native Interface Programming