Esempi di forzatura della liberazione della memoria nativa diretta da ByteBuffer è stata allocata, utilizzando sun.misc.Unsafe?

Question

JDK fornisce capacità di allocazione dei cosiddetti ByteBuffer diretti, in cui la memoria viene allocata all'esterno dell'heap Java. Questo può essere utile in quanto questa memoria non viene toccata dal garbage collector e come tale non contribuisce al sovraccarico di GC: questo è molto utile per la proprietà di cose che vivono a lungo come cache.

Tuttavia, vi è un problema critico con l'implementazione esistente: la memoria sottostante viene allocata in modo asincrono solo quando il proprietario ByteBuffer è sottoposto a raccolta dei dati inutili; non c'è modo di forzare una deallocazione anticipata. Questo può essere problematico poiché il ciclo GC non è influenzato dalla gestione di ByteBuffers e dato che i ByteBuffer risiedono probabilmente nell'area di memoria di vecchia generazione, è possibile che GC venga chiamato ore dopo che ByteBuffer non è più in uso.

Ma in teoria dovrebbe essere possibile utilizzare direttamente i metodi sun.misc.Unsafe (freeMemory, allocateMemory): questo è ciò che JDK utilizza per allocare/deallocare la memoria nativa. Guardando al codice, una potenziale preoccupazione che vedo è la possibilità di una doppia liberazione della memoria, quindi vorrei assicurarmi che lo stato venga pulito correttamente.

Qualcuno può indicarmi il codice che esegue questa operazione? Idealmente vorrebbe usare questo invece di JNA.

NOTA: Ho visto this question che è un po 'correlato.

Sembra che le risposte indicate siano valide: here è un esempio di codice di Ricerca elastica che utilizza l'idea. Grazie a tutti!

Answer 1

L'utilizzo di sun.misc.Unsafe è difficilmente possibile perché l'indirizzo di base della memoria nativa allocata è una variabile locale del costruttore java.nio.DirectByteBuffer.

In realtà si può forzare liberazione della memoria nativa con il seguente codice:

import sun.misc.Cleaner; 

import java.lang.reflect.Field; 
import java.nio.ByteBuffer; 

... 

public static void main(String[] args) throws Exception { 
    ByteBuffer direct = ByteBuffer.allocateDirect(1024); 
    Field cleanerField = direct.getClass().getDeclaredField("cleaner"); 
    cleanerField.setAccessible(true); 
    Cleaner cleaner = (Cleaner) cleanerField.get(direct); 
    cleaner.clean(); 
} 

Answer 2

Fondamentalmente quello che vuoi è seguire la stessa semantica dell'uso di flussi IO. Proprio come hai bisogno di chiudere uno stream una volta, devi liberare la memoria una volta. Quindi è possibile scrivere il proprio wrapper attorno alle chiamate native rendendo possibile la liberazione anticipata della memoria

Answer 3

C'è un modo molto più semplice per pulire la memoria.

public static void clean(ByteBuffer bb) { 
    if(bb == null) return; 
    Cleaner cleaner = ((DirectBuffer) bb).cleaner(); 
    if (cleaner != null) cleaner.clean(); 
} 

L'utilizzo può fare una grande differenza se si scartano ByteBuffer diretti o memorizzati in memoria abbastanza rapidamente.

Uno dei motivi per cui si utilizza il pulitore per eseguire questa operazione è che è possibile avere più copie delle risorse di memoria sottostanti, ad es. con slice(). e il Pulitore ha un conteggio delle risorse di questi.