ByteBuffer keinen Arbeitsspeicher freigibt

Gibt es keine Lecks.

ByteBuffer.allocateDirect() Speicher zuweist, von der native heap /free-Shop (denke malloc()), die wiederum verpackt in einer ByteBuffer Instanz.

Wenn die ByteBuffer Instanz wird Müll gesammelt, der native Speicher zurückgefordert (sonst würden Sie Leck native Speicher).

Die Sie aufrufen System.gc() in der Hoffnung, den nativen Speicher zurückgefordert sofort. Allerdings aufrufen System.gc() ist nur eine Anfrage, die erklärt, warum Ihre zweite log-Anweisung nicht sagen, Sie Speicher freigegeben wurde: es ist, weil es noch nicht!

In Ihrer situation, gibt es anscheinend genug freier Speicher in den Java-heap und den garbage collector entscheidet, nichts zu tun: als eine Folge, nicht erreichbar ByteBuffer Instanzen nicht erhoben, doch der finalizer ist nicht ausgeführt und systemeigenen Speicher wird nicht freigegeben.

Beachten Sie auch, diese bug in der JVM (nicht sicher, wie es gilt für Dalvik obwohl), wo schwere Zuordnung der direkten Puffer führt zu einem unwiederbringlichen OutOfMemoryError.

Sie kommentierte zu tun, das controlling, die Dinge aus JNI. Dies ist tatsächlich möglich, Sie könnten die folgenden Maßnahmen:

1. veröffentlichen native ByteBuffer allocateNative(long size) Eintrag zeigen Sie, dass:

   • Anrufe void* buffer = malloc(size) reservieren native Speicher
   • umschließt den neu zugewiesenen array in ein ByteBuffer Beispiel mit einem Aufruf (*env)->NewDirectByteBuffer(env, buffer, size);
   • wandelt die ByteBuffer lokale Referenz auf eine Globale mit (*env)->NewGlobalRef(env, directBuffer);

2. veröffentlichen native void disposeNative(ByteBuffer buffer) Eintrag zeigen Sie, dass:

   • Anrufe free() auf der direkten Puffer-Adresse zurückgegeben *(env)->GetDirectBufferAddress(env, directBuffer);
   • löscht das global mit ref (*env)->DeleteGlobalRef(env, directBuffer);

Sobald Sie rufen disposeNative auf die Puffer, die man nicht verwenden sollte die Referenz nicht mehr, so könnte es sehr fehleranfällig ist. Überdenken, ob Sie wirklich brauchen eine solche explizite Kontrolle über die Zuweisung Muster.

Vergessen, was ich sagte über Globale Referenzen. Eigentlich Globale Referenzen sind eine Möglichkeit, um zu speichern eine Referenz, die in nativem code (wie in einer globalen Variablen), so dass ein weiterer Aufruf von JNI-Methoden verwenden können, die einen Verweis. So hätten Sie zum Beispiel:

• von Java, rufen Sie die native Methode foo() schafft einen globalen Verweis aus einem lokalen Bezug (die durch anlegen eines Objekts aus nativen Seite) und speichert diese in einem einheitlichen globalen variable (als jobject)
• wieder zurück, von Java wieder, rufen nativen Methode bar() was bekommt der jobject gespeichert foo() und weitere Prozesse es
• schließlich noch aus Java, ein letzter Aufruf von nativen baz() löscht die Globale Referenz

Sorry für die Verwirrung.

Nicht sicher, ob deine letzten Kommentare sind alt oder was Kasper. Ich habe die folgenden...

JNIEXPORT jobject JNICALL Java_com_foo_allocNativeBuffer(JNIEnv* env, jobject thiz, jlong size)
{
    void* buffer = malloc(size);
    jobject directBuffer = env->NewDirectByteBuffer(buffer, size);
    jobject globalRef = env->NewGlobalRef(directBuffer);

    return globalRef;
}

JNIEXPORT void JNICALL Java_comfoo_freeNativeBuffer(JNIEnv* env, jobject thiz, jobject globalRef)
{
    void *buffer = env->GetDirectBufferAddress(globalRef);

    env->DeleteGlobalRef(globalRef);
    free(buffer);
}

Dann in Java...

mImageData = (ByteBuffer)allocNativeBuffer( mResX * mResY * mBPP );

und

freeNativeBuffer(mImageData);
mImageData = null;

und alles scheint zu funktionieren gut für mich. Vielen Dank Gregor für diese Idee. Der link zu den referenzierten Bug in der JVM hat gone bad.