Overview of JNI object references
The implementation details of how the GC finds a JNI object reference are not detailed in the JNI specification. Instead, the JNI specifies a required behavior that is both reliable and predictable.
Local and global references
Local references are scoped to their creating stack frame and thread, and automatically deleted when their creating stack frame returns. Global references allow native code to promote a local reference into a form usable by native code in any thread attached to the JVM.
Global references and memory leaks
Global references are not automatically deleted, so the programmer must handle the memory management. Every global reference establishes a root for the referent and makes its entire subtree reachable. Therefore, every global reference created must be freed to prevent memory leaks.
Leaks in global references eventually lead to an out-of-memory exception. These errors can be difficult to solve, especially if you do not perform JNI exception handling. See Handling exceptions.
Local references and memory leaks
The automatic garbage collection of local references that are no longer in scope prevents memory leaks in most situations. This automatic garbage collection occurs when a native thread returns to Java (native methods) or detaches from the JVM (Invocation API). Local reference memory leaks are possible if automatic garbage collection does not occur. A memory leak might occur if a native method does not return to the JVM, or if a program that uses the Invocation API does not detach from the JVM.
Consider the code in the following example, where native code creates new local references in a loop:
while ( <condition> )
jobject myObj = (*env)->NewObject( env, clz, mid, NULL );
if ( NULL != myObj )
/* we know myObj is a valid local ref, so use it */
jclass myClazz = (*env)->GetObjectClass(env, myObj);
/* uses of myObj and myClazz, etc. but no new local refs */
/* Without the following calls, we would leak */
(*env)->DeleteLocalRef( env, myObj );
(*env)->DeleteLocalRef( env, myClazz );
} /* end while */
Although new local references overwrite the
inside the loop, every local reference is kept in the root set. These references
must be explicitly removed by the DeleteLocalRef call.
Without the DeleteLocalRef calls, the local references
are leaked until the thread returned to Java or
detached from the JVM.
JNI weak global references
Weak global references are a special type of global reference. They can be used in any thread and can be used between native function calls, but do not act as GC roots. The GC disposes of an object that is referred to by a weak global reference at any time if the object does not have a strong reference elsewhere.
You must use weak global references with caution. If the object referred to by a weak global reference is garbage collected, the reference becomes a null reference. A null reference can only safely be used with a subset of JNI functions. To test if a weak global reference has been collected, use the IsSameObject JNI function to compare the weak global reference to the null value.
It is not safe to call most JNI functions with a weak global reference, even if you have tested that the reference is not null, because the weak global reference could become a null reference after it has been tested or even during the JNI function. Instead, a weak global reference should always be promoted to a strong reference before it is used. You can promote a weak global reference using the NewLocalRef or NewGlobalRef JNI functions.
Weak global references use memory and must be freed with the DeleteWeakGlobalRef JNI function when it is no longer needed. Failure to free weak global references causes a slow memory leak, eventually leading to out-of-memory exceptions.
For information and warnings about the use of JNI global weak references, see the JNI specification.
JNI reference management
There are a set of platform-independent rules for JNI reference management
These rules are:
- JNI references are valid only in threads attached to a JVM.
- A valid JNI local reference in native code must be obtained:
- As a parameter to the native code
- As the return value from calling a JNI function
- A valid JNI global reference must be obtained from another valid JNI reference (global or local) by calling NewGlobalRef or NewWeakGlobalRef.
- The null value reference is always valid, and can be used in place of any JNI reference (global or local).
- JNI local references are valid only in the thread that creates them and remain valid only while their creating frame remains on the stack.
- Overwriting a local or global reference in native storage with a null value does not remove the reference from the root set. Use the appropriate Delete*Ref JNI function to remove references from root sets.
- Many JNI functions (such as FindClass and NewObject) return a null value if there is an exception pending. Comparing the returned value to the null value for these calls is semantically equivalent to calling the JNI ExceptionCheck function. See the JNI specification for more details.
- A JNI local reference must never be used after its creating frame returns, regardless of the circumstances. It is dangerous to store a JNI local reference in any process static storage.