java - 从 Java 和 Python 调用 native 库时如何释放内存？

Question

我正在使用 OpenCV 的 Java 包装器。我之前也使用过 Python 包装器。我阅读了以下有关 JNI 的内容:

The JNI framework does not provide any automatic garbage collection for non-JVM
memory resources allocated by code executing on the native side.

我很好奇在使用 Java 包装器和 Python 包装器时如何释放本地库动态分配的内存？

Answer 1

JNI 框架不提供自动垃圾回收 外部资源，但包装器为语言提供绑定(bind) 会的。

Python 提供自动垃圾回收，但是如果你使用 C API 您必须手动获取和释放任何 references到 python 对象并管理对 native 数据的引用。 Py_INCREF()将要 增加 PyObject * 的引用计数一个让你 可以确保它在您调用 Py_DECREF() 之前一直有效在 稍后相同的对象。一旦引用，内存将被释放 计数达到零(是的，这是一种简化，因为垃圾 收集器和循环引用，但原则上是正确的)。

Java(JVM)也提供了自动垃圾回收，但是如果你 使用 JNI 你必须手动管理所有 references给你的 对象。通过使用，这与 Python 的行为类似 (*env)->DeleteLocalRef()或 (*env)->Release...()(取决于 对象的类型)释放获取的对象的局部引用 通过 JNI。

假设您想包装原生 C 库 foo:

// foo.h
typedef struct {
  char * bar;
} foo;

foo * foo_new(const char * bar);
void foo_delete(foo * self);

// foo.c
#include <stdlib.h>
#include <string.h>
#include "foo.h"

foo * foo_new(const char * bar) {
  // Allocate foo.
  foo * self = malloc(sizeof(foo));
  if (self == NULL) {
    return NULL;
  }
  memset(self, 0, sizeof(foo));
  // Copy bar to foo.
  size_t bar_len = strlen(bar);
  char * bar_copy = malloc(sizeof(char) * (bar_len + 1));
  if (bar_copy == NULL) {
    foo_delete(self);
    return NULL;
  }
  strncpy(bar_copy, bar, bar_len);
  bar_copy[bar_len] = '\0';
  self->bar = bar_copy;
  // Return foo pointer.
  return self;
}

void foo_delete(foo * self) {
  if (self == NULL) {
    return;
  }
  // Free bar.
  if (self->bar != NULL) {
    free(self->bar);
    self->bar = NULL;
  }
  // Free foo.
  free(self);
}

因此，如果您要编写 Python 绑定(bind)到 native foo 库，您将 需要一个包装器 Python 对象，它存储指向 native 数据的指针 包装器将管理它。当 Python 包装器对象是 销毁，它必须释放任何指向 native 数据的指针，并且 释放对 Python 对象的任何引用。

// pyfoo.c
#include <Python.h>
#include "foo.h"

// class PyFoo wraps struct foo.
typedef struct {
  PyObject_HEAD;
  foo * foo;
} PyFoo;

static PyObject * PyFoo_new(PyTypeObject * type, PyObject * args, PyObject * kwargs) {
  // Parse bar from arguments.
  const char * bar;
  if (!PyArg_ParseTuple(args, "s", &bar)) {
    return NULL;
  }
  // Allocate PyFoo.
  PyFoo * self;
  self = (PyFoo *)type->tp_alloc(type, 0);
  if (self == NULL) {
    return NULL;
  }
  // Create internal foo with bar.
  self->foo = foo_new(bar);
  if (self->foo == NULL) {
    Py_DECREF(self);
    return NULL;
  }
  // Return PyFoo instance.
  return (PyObject *)self;
}

static void PyFoo_dealloc(PyFoo * self) {
  // Delete internal foo pointer.
  foo_delete(self->foo);
  // Free python object.
  self->ob_type->tp_free((PyObject *)self);
}

static PyObject * PyFoo_bar(PyFoo * self) {
  // Return a copy of bar.
  return (PyObject *)PyString_FromString(self->foo->bar)
}

static PyMethodDef PyFoo_methods[] = {
  {"foo", (PyCFunction)PyFoo_bar, METH_NOARGS, "Returns foo."},
  {NULL}, // Sentinel.
};

要用 Java 包装 native foo 库，您需要定义包装器 Java 类(class)。它将使用 JNI 与 native 库进行通信，并且 存储相关的 native 指针(可能是创建一个通用包装器 每个 native 指针的实例)。在类析构函数中(或最接近你 可以在 Java 中获取)，然后它会使用 native 库来释放 native 库指针。

// Foo.java
public class Foo {

  private long foo_ptr;

  public Foo(String bar) {
    // Create internal foo with bar.
    this.foo_ptr = this.foo_new(bar)
  }

  protected void finalize() {
    // Delete internal foo.
    this.foo_delete(this.foo_ptr);
  }

  public String getBar() {
    // Return a copy of bar.
    return this.foo_bar(this.foo_ptr);
  }

  static {
    System.loadLibrary("javafoo");
  }

  private native long foo_new(String bar);
  private native void foo_delete(long foo_ptr);
  private native String foo_bar(long foo);
}

// javafoo.c
#include <jni.h>
#include "foo.h"

JNIEXPORT jlong JNICALL Java_Foo_foo_new(JNIEnv * env, jstring jbar) {
  // Convert java string to c string.
  char * bar = (*env)->GetStringUTFChars(env, jbar, NULL);
  if (bar == NULL) {
    return 0;
  }
  // Create internal foo with bar.
  foo * self = foo_new(bar);
  if (self == NULL) {
    (*env)->ReleaseStringUTFChars(env, jbar, bar);
    return 0;
  }
  // Delete bar c string.
  (*env)->ReleaseStringUTFChars(env, jbar, bar);
  // Return foo pointer as long.
  return (jlong)self;
}

JNIEXPORT void JNICALL Java_Foo_foo_delete(JNIEnv * env, jlong foo_ptr) {
  // Convert foo pointer from long.
  foo * self = (foo *)foo_ptr;
  // Delete internal foo.
  foo_delete(self);
}

JNIEXPORT jstring JNICALL Java_Foo_foo_bar(JNIEnv * env, jlong foo_ptr) {
  // Convert foo pointer from long.
  foo * self = (foo *)foo_ptr;
  // Create java string from bar c string.
  jstring jbar = (*env)->NewStringUTF(env, self->bar);
  // Return bar java string.
  return jbar;
}

注意:这些源代码示例仅作为简单示例，并未 经过测试，可能会省略细节，并且不一定遵循既定的， 最佳实践。