https://github.com/jnr/jnr-ffi/blob/master/docs/MemoryManagement.md
在jnr中，可以使用Memory类来分配和操作本地内存。当使用Memory类分配内存时，Java的垃圾回收器会自动跟踪这些内存块，并在不再使用时进行回收。

import jnr.ffi.Memory;
import jnr.ffi.Pointer;

public class MyClass {
    public void allocateAndFreeMemory(int size) {
        Pointer pointer = Memory.allocateDirect(size);
        // 使用pointer进行操作
        // ...

        // 不再使用时，内存会被操作
        // ...

        // 不再使用时，内存会被自动回收
    }
}

package com.springboot.springbootdemo;

import jnr.ffi.*;
import jnr.ffi.Runtime;
import jnr.ffi.annotations.In;
import jnr.ffi.provider.MemoryManager;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.Executors;

public class Main {

    public interface LibTest3 { // A representation of libC in Java
        String func1(@In String str);
        String func2(@In String str);
        Pointer func4();
        int len(@In String str);
    }

    public static void main(String[] args) {
        LibTest3 libTest3 = LibraryLoader.create(LibTest3.class).load("test3"); // load the "c" library into the libc variable
//        System.out.printf("func1:%s\n",libTest3.func1("Hello World!"));
//        System.out.printf("func2:%s\n",libTest3.func2("Hello World!"));

        Pointer memory = Memory.allocateDirect(Runtime.getSystemRuntime(), 1024);
        MemoryManager memoryManager = Runtime.getSystemRuntime().getMemoryManager();

        while (true){
            System.out.println(123);
            libTest3.func4();
        }
        ObjectReferenceManager<Object> objectObjectReferenceManager = ObjectReferenceManager.newInstance(Runtime.getRuntime(libTest3));
        objectObjectReferenceManager.add();
        objectObjectReferenceManager.remove();

    }
}

g++ -dynamiclib -o /Users/xxx/IdeaProjects/SpringBootDemo/libtest3.dylib test3.cpp

#include<stdio.h>
#include <iostream>
#include <stdlib.h>
#include <string.h>

extern "C"  char* func1(const char* str){
    printf("from c in:%s\n",str);
    char * str2 = new char[strlen(str)];
    strcpy (str2,str);
    printf("from c out:%s\n",str2);
    return str2;
}

extern "C"  char* func2(const char* str){
    printf("from c in:%s\n",str);
    char * str2 = (char *) malloc(sizeof(char) * strlen(str) );
    strcpy (str2,str);
    printf("from c out:%s\n",str2);
    return str2;
}

extern "C" int func3(const char* str){
    printf("str:%s",str);
    char str2[10] = {'a','b','c','\0'};
    printf(str2);
    return strlen(str);
}

extern "C" long * func4(){
    long * str2 = new long[10000000000];
    return str2;
}


int main(){
    // prt("abc");
    // printf(123);
    // int b = len("Hello");
    char* b = func1("Hello");
    // printf("%s",b);
    return 0;
}

qsort

package qsort;


import jnr.ffi.LibraryLoader;
import jnr.ffi.Memory;
import jnr.ffi.Pointer;
import jnr.ffi.Runtime;
import jnr.ffi.annotations.Delegate;
import jnr.ffi.types.size_t;

import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.IntBuffer;

/**
 * Hello world!
 *
 */
public class Qsort {

    public static interface Compare {
        @Delegate public int compare(Pointer p1, Pointer p2);
    }

    public static final class IntCompare implements Compare {
        public int compare(Pointer p1, Pointer p2) {
            int i1 = p1.getInt(0);
            int i2 = p2.getInt(0);

            return i1 < i2 ? -1 : i1 > i2 ? 1 : 0;
        }
    }

    public interface LibC {
        public int qsort(int[] data, @size_t int count, @size_t int width, Compare compare);
        public int qsort(Pointer data, @size_t long count, @size_t int width, Compare compare);
        public int qsort(Buffer data, @size_t long count, @size_t int width, Compare compare);
    }

    public static void main(String[] args) {

        LibC libc = LibraryLoader.create(LibC.class).load("c");

        int[] numbers = { 2, 1 };
        System.out.println("qsort using java int[] array");
        System.out.println("before, numbers[0]=" + numbers[0] + " numbers[1]=" + numbers[1]);
        libc.qsort(numbers, 2, 4, new IntCompare());
        System.out.println("after, numbers[0]=" + numbers[0] + " numbers[1]=" + numbers[1]);
        System.out.append('\n');

        System.out.println("sort using native memory");
        Pointer memory = Memory.allocate(Runtime.getRuntime(libc), 8);
        memory.putInt(0, 4);
        memory.putInt(4, 3); // offset is in bytes
        System.out.println("before, memory[0]=" + memory.getInt(0) + " memory[1]=" + memory.getInt(4));
        libc.qsort(memory, 2, 4, new IntCompare());
        System.out.println("after, memory[0]=" + memory.getInt(0) + " memory[1]=" + memory.getInt(4));

        System.out.append('\n');
        System.out.println("qsort using NIO buffer");
        IntBuffer intBuffer = ByteBuffer.allocateDirect(8).order(ByteOrder.nativeOrder()).asIntBuffer();
        intBuffer.put(0, 6);
        intBuffer.put(1, 5); // offset is in units of int elements

        System.out.println("before, buffer[0]=" + intBuffer.get(0) + " buffer[1]=" + intBuffer.get(1));
        libc.qsort(intBuffer, 2, 4, new IntCompare());
        System.out.println("after, buffer[0]=" + intBuffer.get(0) + " buffer[1]=" + intBuffer.get(1));

    }
}