Project: Java, JNI (C++), Android.
I’m going to manage native C++ object’s lifetime by creating a managed wrapper class, which will hold a pointer to the native object (as a long member) and will delete the native object in it’s overridden finalize() method. See this question for details.
The C++ object does not consume other types of resources, only memory. The memory footprint of the object is not extremely high, but it is essentially higher than 64 bit of a long in Java. Is there any way to tell Java’s GC, that my wrapper is responsible for more than just a long value, and it’s not a good idea to create millions of such objects before running garbage collection? In .NET there is a GC’s AddMemoryPressure() method, which is there for exactly this purpose. Is there an equivalent in Java?
After some more googling, I’ve found a good article from IBM Research Center.
Briefly, they recommend using Java heap instead of native heap for native objects. This way memory pressure on JVM garbage collector is more realistic for the native objects, referenced from Java code through handles.
To achieve this, one needs to override the default C++ heap allocation and deallocation functions: operator new and operator delete. In the operator new, if JVM is available (JNI_OnLoad has been already called), then the one calls NewByteArray and GetByteArrayElements, which returns the allocated memory needed. To protect the created ByteArray from being garbage collected, the one also need to create a NewGlobalRef to it, and store it e.g. in the same allocated memory block. In this case, we need to allocate as much memory as requested, plus the memory for the references. In the operator delete, the one needs to DeleteGlobalRef and ReleaseByteArrayElements. In case JVM is not available, the one uses native malloc and free functions instead.