Connect life time of C++ objects to Java object - c++

Question

I have a C++ library with objects and am using this in conjunction with Java over JNI. Ideally, I'd like to tie the life cycle of the C++ objects to their Java equivalents and make it controllable from Java. Important to note is that the application is multi-threaded, so the C++ objects are accessed from multiple threads, and that those objects aren't modified after their initial construction. My current implementation looks something like this:
struct Tree {
int age = 0;
std::string type;
}
typedef Tree* TreeHandle;
/*
* Class: com_example_Tree
* Method: initialize
* Signature: ([Lcom/example/Tree;)I
*/
JNIEXPORT jlong JNICALL Java_com_example_Tree_initialize
(JNIEnv * env, jclass cls, jobject j_tree) {
auto tree_ptr = new Tree();
return (jlong) tree_ptr;
}
/*
* Class: com_example_Tree
* Method: dispose
* Signature: (I)V
*/
JNIEXPORT void JNICALL Java_com_example_Tree_dispose
(JNIEnv * env, jclass cls, jlong j_tree_handle) {
auto tree_ptr = reinterpret_cast<TreeHandle*>(j_tree_handle);
delete tree_ptr;
}
My Java part then looks like this:
class Tree implements AutoClosable {
static {
System.load("/path/to/tree.so");
}
private long handle;
public Tree() {
this.handle = initialize();
}
#Override
protected void finalize() {
if (this.handle != 0) {
this.close();
}
}
#override
public synchronized void close() {
dispose(this.handle);
this.handle = 0;
}
private static native long initialize();
private static native void dispose();
}
However, the result is that I have some global objects floating around in memory that are only accessible via a C-style pointer. Is there a more modern way of achieving the same, i.e., using smart pointers or directly designing the C++ objects as members of the Java class?