java 之JNA中的Memory和Pointer的使用方法

简介

我们知道在native的代码中有很多指针，这些指针在jna中被映射成为pointer。除了pointer之外，jna还提供了更加强大的memory类，本文将会一起探讨jna中的pointer和memory的使用。

pointer

pointer是jna中引入的类，用来表示native方法中的指针。大家回想一下native方法中的指针到底是什么呢？

native方法中的指针实际上就是一个地址，这个地址就是真正对象的内存地址。所以在pointer中定义了一个peer属性，用来存储真正对象的内存地址：

protected long peer;

实时上，pointer的构造函数就需要传入这个peer参数：

public pointer(long peer) {
        this.peer = peer;
    }

接下来我们看一下如何从pointer中取出一个真正的对象，这里以byte数组为例：

    public void read(long offset, byte[] buf, int index, int length) {
        native.read(this, this.peer, offset, buf, index, length);
    }

实际上这个方法调用了native.read方法，我们继续看一下这个read方法：

static native void read(pointer pointer, long baseaddr, long offset, byte[] buf, int index, int length);

可以看到它是一个真正的native方法，用来读取一个指针对象。

除了byte数组之外，pointer还提供了很多其他类型的读取方法。

又读取就有写入，我们再看下pointer是怎么写入数据的：

    public void write(long offset, byte[] buf, int index, int length) {
        native.write(this, this.peer, offset, buf, index, length);
    }

同样的，还是调用 native.write方法来写入数据。

这里native.write方法也是一个native方法：

static native void write(pointer pointer, long baseaddr, long offset, byte[] buf, int index, int length);

pointer还提供了很多其他类型数据的写入方法。

当然还有更加直接的get*方法：

public byte getbyte(long offset) {
        return native.getbyte(this, this.peer, offset);
    }

特殊的pointer:opaque

在pointer中，还有两个createconstant方法，用来创建不可读也不可写的pointer：

    public static final pointer createconstant(long peer) {
        return new opaque(peer);
    }

    public static final pointer createconstant(int peer) {
        return new opaque((long)peer & 0xffffffff);
    }

实际上返回的而是opaque类，这个类继承自pointer，但是它里面的所有read或者write方法，都会抛出unsupportedoperationexception：

    private static class opaque extends pointer {
        private opaque(long peer) { super(peer); }
        @override
        public pointer share(long offset, long size) {
            throw new unsupportedoperationexception(msg);
        }

memory

pointer是基本的指针映射，如果对于通过使用native的malloc方法分配的内存空间而言，除了pointer指针的开始位置之外，我们还需要知道分配的空间大小。所以一个简单的pointer是不够用了。

这种情况下，我们就需要使用memory。

memory是一种特殊的pointer, 它保存了分配出来的空间大小。

我们来看一下memory的定义和它里面包含的属性：

public class memory extends pointer {
...
    private static referencequeue<memory> queue = new referencequeue<memory>();
    private static linkedreference head; // the head of the doubly linked list used for instance tracking
    private static final weakmemoryholder buffers = new weakmemoryholder();
    private final linkedreference reference; // used to track the instance
    protected long size; // size of the malloc'ed space
...
}

memory里面定义了5个数据，我们接下来一一进行介绍。

首先是最为重要的size，size表示的是memory中内存空间的大小，我们来看下memory的构造函数：

    public memory(long size) {
        this.size = size;
        if (size <= 0) {
            throw new illegalargumentexception("allocation size must be greater than zero");
        }
        peer = malloc(size);
        if (peer == 0)
            throw new outofmemoryerror("cannot allocate " + size + " bytes");

        reference = linkedreference.track(this);
    }

可以看到memory类型的数据需要传入一个size参数，表示memory占用的空间大小。当然，这个size必须要大于0.

然后调用native方法的malloc方法来分配一个内存空间，返回的peer保存的是内存空间的开始地址。如果peer==0，表示分配失败。

如果分配成功，则将当前memory保存到linkedreference中，用来跟踪当前的位置。

我们可以看到memory中有两个linkedreference，一个是head，一个是reference。

linkedreference本身是一个weakreference，weekreference引用的对象只要垃圾回收执行，就会被回收，而不管是否内存不足。

private static class linkedreference extends weakreference<memory>

我们看一下linkedreference的构造函数：

private linkedreference(memory referent) {
            super(referent, queue);
        }

这个queue是referencequeue，表示的是gc待回收的对象列表。

我们看到memory的构造函数除了设置size之外，还调用了：

reference = linkedreference.track(this);

仔细看linkedreference.track方法：

   static linkedreference track(memory instance) {
            // use a different lock here to allow the finialzier to unlink elements too
            synchronized (queue) {
                linkedreference stale;

                // handle stale references here to avoid gc overheating when memory is limited
                while ((stale = (linkedreference) queue.poll()) != null) {
                    stale.unlink();
                }
            }

            // keep object allocation outside the syncronized block
            linkedreference entry = new linkedreference(instance);

            synchronized (linkedreference.class) {
                if (head != null) {
                    entry.next = head;
                    head = head.prev = entry;
                } else {
                    head = entry;
                }
            }

            return entry;
        }

这个方法的意思是首先从queue中拿出那些准备被垃圾回收的memory对象，然后将其从linkedreference中unlink。最后将新创建的对象加入到linkedreference中。

因为memory中的queue和head都是类变量，所以这个linkedreference保存的是jvm中所有的memory对象。

最后memory中也提供了对应的read和write方法，但是memory中的方法和pointer不同，memory中的方法多了一个boundscheck,如下所示：

    public void read(long boff, byte[] buf, int index, int length) {
        boundscheck(boff, length * 1l);
        super.read(boff, buf, index, length);
    }

    public void write(long boff, byte[] buf, int index, int length) {
        boundscheck(boff, length * 1l);
        super.write(boff, buf, index, length);
    }

为什么会有boundscheck呢？这是因为memory和pointer不同，memory中有一个size的属性，用来存储分配的内存大小。使用boundscheck就是来判断访问的地址是否出界，用来保证程序的安全。