我使用了以下方法：
在JNI代码中，创建一个结构体来保存对所需对象引用。当你第一次创建这个结构体时，把它的指针作为long返回给java。然后，在java中，你只需要调用任何带有long作为参数的方法，然后在C中将其转换为指向你的结构体的指针。
该结构将位于堆中，因此它不会在不同的JNI调用之间被清除。
编辑：我不认为你可以使用long ptr = (long)&address;，因为address是一个静态变量。使用Gunslinger47建议的方式，即。创建类或结构的新示例（使用new或malloc）并传递其指针。

在C++中，你可以使用任何你想要的机制来分配/释放内存：堆栈、malloc/free、new/delete或任何其他自定义实现。唯一的要求是，如果你用一种机制分配了一块内存，你必须用同样的机制释放它，所以你不能在堆栈变量上调用free，也不能在malloc ed内存上调用delete。
JNI有自己的机制来分配/释放JVM内存：

• NewObject/DeleteLocalRef
• NewGlobalRef/DeleteGlobalRef
• NewWeakGlobalRef/DeleteWeakGlobalRef

它们遵循相同的规则，唯一的问题是本地引用可以被删除，无论是显式的，使用PopLocalFrame，还是隐式的，当本机方法退出时。
JNI不知道你是如何分配内存的，所以当你的函数退出时，它不能释放内存。堆栈变量显然会被销毁，因为你仍然在写C++，但你的GPU内存仍然有效。
唯一的问题是如何在后续调用中访问内存，然后你可以使用Gunslinger 47的建议：

JNIEXPORT jlong JNICALL Java_MyJavaClass_Function1() {
    MyClass* pObject = new MyClass(...);
    return (long)pObject;
}

JNIEXPORT void JNICALL Java_MyJavaClass_Function2(jlong lp) {
    MyClass* pObject = (MyClass*)lp;
    ...
}

虽然来自@denis-tulskiy的公认答案确实有道理，但我个人还是遵循了here的建议。
因此，不要使用伪指针类型，如jlong（如果你想在32位的arch上保存一些空间，也可以使用jint），而是使用ByteBuffer。举例来说：

MyNativeStruct* data; // Initialized elsewhere.
jobject bb = (*env)->NewDirectByteBuffer(env, (void*) data, sizeof(MyNativeStruct));

您可以稍后重新使用它：

jobject bb; // Initialized elsewhere.
MyNativeStruct* data = (MyNativeStruct*) (*env)->GetDirectBufferAddress(env, bb);

对于非常简单的情况，此解决方案非常易于使用。假设您有：

struct {
  int exampleInt;
  short exampleShort;
} MyNativeStruct;

在Java方面，你只需要做：

public int getExampleInt() {
  return bb.getInt(0);
}

public short getExampleShort() {
  return bb.getShort(4);
}

这让你不必编写 * 大量 * 样板代码！然而，应该注意字节顺序，如here所解释的。

Java不知道如何处理指针，但它应该能够存储来自本机函数返回值的指针，然后将其交给另一个本机函数处理。C指针只不过是核心的数值。
另一个贡献者必须告诉你在JNI调用之间是否会清除指向的图形内存，以及是否有任何变通方法。

我知道这个问题已经得到了官方的回答，但我想补充一下我的解决方案：不要尝试传递指针，而是将指针放在Java数组中（索引为0）并将其传递给JNI。JNI代码可以使用GetIntArrayRegion/SetIntArrayRegion获取和设置数组元素。
在我的代码中，我需要本机层来管理文件描述符（一个开放的套接字）。Java类保存一个int[1]数组并将其传递给本机函数。本机函数可以对它做任何事情（get/set），并将结果放回数组中。

如果在本机函数内部动态分配内存（在堆上），则不会删除它。换句话说，您可以使用指针、静态变量等来保留对本机函数的不同调用之间的状态。
换个Angular 想想：你能做什么安全地保存在一个函数调用中，从另一个C++程序调用？同样的事情也适用于这里。当一个函数退出时，该函数调用的堆栈上的任何内容都将被销毁;但是堆上的任何东西都会被保留，除非你显式地删除它。
简短回答：只要你不释放你返回给调用函数的结果，它将保持有效，以便以后重新进入。完事后记得清理干净。

最好完全按照Unsafe.allocateMemory的方式来执行此操作。
创建你的对象，然后将它输入到（uintptr_t），这是一个32/64位的无符号整数。

return (uintptr_t) malloc(50);

void * f = (uintptr_t) jlong;

这是唯一正确的做法。
下面是Unsafe.allocateMemory所做的健全性检查。

inline jlong addr_to_java(void* p) {
  assert(p == (void*)(uintptr_t)p, "must not be odd high bits");
  return (uintptr_t)p;
}

UNSAFE_ENTRY(jlong, Unsafe_AllocateMemory(JNIEnv *env, jobject unsafe, jlong size))
  UnsafeWrapper("Unsafe_AllocateMemory");
  size_t sz = (size_t)size;
  if (sz != (julong)size || size < 0) {
    THROW_0(vmSymbols::java_lang_IllegalArgumentException());
  }
  if (sz == 0) {
    return 0;
  }
  sz = round_to(sz, HeapWordSize);
  void* x = os::malloc(sz, mtInternal);
  if (x == NULL) {
    THROW_0(vmSymbols::java_lang_OutOfMemoryError());
  }
  //Copy::fill_to_words((HeapWord*)x, sz / HeapWordSize);
  return addr_to_java(x);
UNSAFE_END

下面是另一种方法，在java-c C glue文件中使用全局static变量，通过引用将变量传递给C，并返回已从C更改为Java的变量。需要两个Java函数调用。
下面是一个在Kotlin中使用Android开发的示例：
首先，C代码（一个简单的函数，递增通过引用传递的变量）：

// lib.c
void cfunction(int *number)
{
    *number += 1;
}

然后我们通常会像胶水一样使用另一个C代码来管理Java的白痴特性

// glue.c
static int number;

void cfunction(int *);

JNIEXPORT void JNICALL
Java_com_example_someapp_MainActivity_inc(JNIEnv* env, jobject thiz, jint value)
{
    number = value;
    cfunction(&number);
}

JNIEXPORT jint JNICALL
Java_com_example_someapp_MainActivity_getnumber(JNIEnv* env, jobject thiz)
{
    return number;
}

它使用一个全局变量number（由于static关键字，只能在文件glue. c中访问），并且可以使用getter函数getnumber从外部访问。所以基本上我们需要一个额外的函数和一个静态全局变量来调用一个需要指针并改变其引用的C库。
CMakeLists.txt看起来像这样：

cmake_minimum_required(VERSION 3.18.1)

project("someapp")

add_library(somelib SHARED
            glue.c
            lib.c)

最后是Android（Kotlin）部分：

package com.example.someapp

// imports

class MainActivity : ComponentActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // How to use a C call by ref in Kotlin
        inc(4)
        val number = getnumber()
        Toast.makeText(this, number.toString(), Toast.LENGTH_LONG).show()
    }

    external fun inc(number: Int)

    external fun getnumber(): Int

    companion object {
        init {
            System.loadLibrary("somelib")
        }
    }
}

它应该显示5。