Do I need to explicitly dispose a jbyteArray? - java-native-interface

Question

I am writing a function which first creates a new jbyteArray, which, if everything else works, it will return. If everything else is not successful in the function it will return NULL instead.
However if an error occurs somewhere during the function after I have successfully called NewByteArray(), so I need to explicitly dispose of the jbyteArray before returning, or can I simply leave it to the garbage collector ?
In a rough code sketch :
jbyteArray makeAndFill( JNIEnv *env )
{
jbyteArray ba = NULL ;
ba = (*env)->NewByteArray( env, 1000 ) ;
if( ba == NULL )
return NULL ;
/* so far so good /
if( fillme( ba ) )
{
/* Whoops, a problem ...
*
* DO I need to free the jbyteArray explicitly before
* returning NULL ?
*/
return NULL ;
}
/* everything was fine
*/
return ba ;
}
You can assume that fillme() does all the required Get and Release code and simply returns FALSE if soem some reason it had a problem. If fillme() cannot do it's job properly we simply want the function to return a NULL.
My understanding is that if I do not return the jbyteArray to JAVA "proper" from JNI it will simply be garbage collected. Is that correct ?

Answer 1

If this is in a function that's called via a Java native method, then the runtime will take care of the jbyteArray local reference for you. From the documentation: "Local references are valid for the duration of a native method call, and are automatically freed after the native method returns.". Once the local reference is freed and there aren't any other references to it (returning the object to Java creates a new reference), the object becomes eligible for garbage collection.
The exception would be, if you had a lot of references like this. There's a limit to how many local references a VM can handle, but if you stay below that, you're good.
If this in a function in a non-Java process where a VM has been created with JNI_CreateJavaVM(), you have to explicitly delete every reference that's created outside a Java native method call. Inside a native method call the VM creates a space for references for you that it destroys when the native method returns. When you get yourself an env pointer via JNI_CreateJavaVM() or AttachCurrentThread() or GetEnv(), the VM will not manage the references created for that env for you.
One more edit: seems as if DetachCurrentThread() has been seen to free local references. I'm pretty sure, however, I've read about problems where it did not. Maybe it's implementation dependent, maybe the reported problems were due to a bug. The documentation doesn't say for sure, so I'd prefer to not rely on it.