Java中内存分配的几种方法

一、数组分配的上限

java里数组的大小是受限制的，因为它使用的是int类型作为数组下标。这意味着你无法申请超过integer.max_value（2^31-1）大小的数组。这并不是说你申请内存的上限就是2g。你可以申请一个大一点的类型的数组。比如：

final long[] ar = new long[ integer.max_value ];

这个会分配16g -8字节，如果你设置的-xmx参数足够大的话（通常你的堆至少得保留50%以上的空间，也就是说分配16g的内存，你得设置成-xmx24g。这只是一般的规则，具体分配多大要看实际情况）。

不幸的是，在java里，由于数组元素的类型的限制，你操作起内存来会比较麻烦。在操作数组方面，bytebuffer应该是最有用的一个类了，它提供了读写不同的java类型的方法。它的缺点是，目标数组类型必须是byte[]，也就是说你分配的内存缓存最大只能是2g。

二、把所有数组都当作byte数组来进行操作

假设现在2g内存对我们来说远远不够，如果是16g的话还算可以。我们已经分配了一个long[]，不过我们希望把它当作byte数组来进行操作。在java里我们得求助下c程序员的好帮手了——sun.misc.unsafe。这个类有两组方法：getn(object, offset),这个方法是要从object偏移量为offset的位置获取一个指定类型的值并返回它，n在这里就是代表着那个要返回值的类型，而putn(object,offset,value）方法就是要把一个值写到object的offset的那个位置。

不幸的是，这些方法只能获取或者设置某个类型的值。如果你从数组里拷贝数据，你还需要unsafe的另一个方法，copymemory(srcobject, srcoffset, destobject,destoffet,count)。这和system.arraycopy的工作方式类似，不过它拷贝的是字节而不是数组元素。

想通过sun.misc.unsafe来访问数组的数据，你需要两个东西：

1.数组对象里数据的偏移量
2.拷贝的元素在数组数据里的偏移量
arrays和java别的对象一样，都有一个对象头，它是存储在实际的数据前面的。这个头的长度可以通过unsafe.arraybaseoffset(t[].class)方法来获取到，这里t是数组元素的类型。数组元素的大小可以通过unsafe.arrayindexscale(t[].class) 方法获取到。这也就是说要访问类型为t的第n个元素的话，你的偏移量offset应该是arrayoffset+n*arrayscale。

我们来写个简单的例子吧。我们分配一个long数组，然后更新它里面的几个字节。我们把最后一个元素更新成-1（16进制的话是0xffff ffff ffff ffff)，然再逐个清除这个元素的所有字节。

final long[] ar = new long[ 1000 ];
final int index = ar.length - 1;
ar[ index ] = -1; //ffff ffff ffff ffff

system.out.println( "before change = " + long.tohexstring( ar[ index ] ));

for ( long i = 0; i < 8; ++i )
{
    unsafe.putbyte( ar, longarrayoffset + 8l * index + i, (byte) 0);
    system.out.println( "after change: i = " + i + ", val = "  +  long.tohexstring( ar[ index ] ));
}

想运行上面 这个例子的话，得在你的测试类里加上下面的静态代码块：

private static final unsafe unsafe;
static
{
    try
    {
        field field = unsafe.class.getdeclaredfield("theunsafe");
        field.setaccessible(true);
        unsafe = (unsafe)field.get(null);
    }
    catch (exception e)
    {
        throw new runtimeexception(e);
    }
}

private static final long longarrayoffset = unsafe.arraybaseoffset(long[].class);
输出的结果是：

before change = ffffffffffffffff
after change: i = 0, val = ffffffffffffff00
after change: i = 1, val = ffffffffffff0000
after change: i = 2, val = ffffffffff000000
after change: i = 3, val = ffffffff00000000
after change: i = 4, val = ffffff0000000000
after change: i = 5, val = ffff000000000000
after change: i = 6, val = ff00000000000000
after change: i = 7, val = 0

三、sun.misc.unsafe的内存分配

上面也说过了，在纯java里我们的能分配的内存大小是有限的。这个限制在java的最初版本里就已经定下来了，那个时候人们都不敢相像分配好几个g的内存是什么情况。不过现在已经是大数据的时代了，我们需要更多的内存。在java里，想获取更多的内存有两个方法：

1.分配许多小块的内存，然后逻辑上把它们当作一块连续的大内存来使用。
2.使用sun.misc.unsafe.allcatememory(long)来进行内存分配。
第一个方法只是从算法的角度来看比较有意思一点，所以我们还是来看下第二个方法。

sun.misc.unsafe提供了一组方法来进行内存的分配，重新分配，以及释放。它们和c的malloc/free方法很像：

1.long unsafe.allocatememory(long size)——分配一块内存空间。这块内存可能会包含垃圾数据（没有自动清零）。如果分配失败的话会抛一个java.lang.outofmemoryerror的异常。它会返回一个非零的内存地址（看下面的描述）。
2.unsafe.reallocatememory(long address, long size)——重新分配一块内存，把数据从旧的内存缓冲区（address指向的地方）中拷贝到的新分配的内存块中。如果地址等于0，这个方法和allocatememory的效果是一样的。它返回的是新的内存缓冲区的地址。
3.unsafe.freememory(long address)——释放一个由前面那两方法生成的内存缓冲区。如果address为0什么也不干 。

这些方法分配的内存应该在一个被称为单寄存器地址的模式下使用：unsafe提供了一组只接受一个地址参数的方法（不像双寄存器模式，它们需要一个object还有一个偏移量offset）。通过这种方式分配的内存可以比你在-xmx的java参数里配置的还要大。

注意：unsafe分配出来的内存是无法进行垃圾回收的。你得把它当成一种正常的资源，自己去进行管理。

下面是使用unsafe.allocatememory分配内存的一个例子，同时它还检查了整个内存缓冲区是不是可读写的：

final int size = integer.max_value / 2;
final long addr = unsafe.allocatememory( size );
try
{
    system.out.println( "unsafe address = " + addr );
    for ( int i = 0; i < size; ++i )
    {
        unsafe.putbyte( addr + i, (byte) 123);
        if ( unsafe.getbyte( addr + i ) != 123 )
            system.out.println( "failed at offset = " + i );
    }
}
finally
{
    unsafe.freememory( addr );
}

正如你所看见的，使用sun.misc.unsafe你可以写出非常通用的内存访问的代码：不管是java里分配的何种内存，你都可以随意读写任意类型的数据。