如何用Java读写堆外内存？

Question

In my Spark program, I'm interested in allocating and using data that is not touched by Java's garbage collector. Basically, I want to do the memory management of such data myself like you would do in C++. Is this a good case of using off heap memory? Secondly, how do you read and write to off heap memory in Java or Scala. I tried searching for examples, but couldn't find any.

Answer 1

Manual memory management is a viable optimization strategy for garbage collected languages. Garbage collection is a known source of overhead and algorithms can be tailored to minimize it. For example, when picking a hash table implementation one might prefer Open Addressing because it allocates its entries manually on the main array instead of handling them to the language memory allocation and its GC. As another example, here's a Trie searcher that packs the Trie into a single byte array in order to mimimize the GC overhead. Similar optimization can be used for regular expressions.

That kind of optimization, when the Java arrays are used as a low-level storage for the data, goes hand in hand with the Data-oriented design , where data is stored in arrays in order to achieve better cache locality. Data-oriented design is widely used in gamedev, where the performance matters.

In JavaScript this kind of array-backed data storage is an important part of asm.js .

The array-backed approach is sufficiently supported by most garbage collectors used in the Java world, as they'll try to avoid moving the large arrays around.

If you want to dig deeper, in Linux you can create a file inside the "/dev/shm" filesystem. This filesystem is backed by RAM and won't be flushed to disk unless your operating system is out of memory. Memory-mapping such files (with FileChannel.map ) is a good enough way to get the off-heap memory directly from the operating system. ( MappedByteBuffer operations are JIT-optimized to direct memory access, minus the boundary checks).

If you want to go even deeper, then you'll have to resort to JNI libraries in order to access the C-level memory allocator, malloc .

Answer 2

If you are not able to achieve "Efficiency with Algorithms, Performance with Data Structures", and if efficiency and performance are so critical, you could consider using "sun.misc.Unsafe". As the name suggests it is unsafe!!!

Spark is already using it as mentioned in project-tungsten .

Also, you can start here , to understand it better!!!

Note: Spark provides a highly concurrent for execution of application and with multiple JVMs mostlikely across multiple machines, manual memory management will be extreamly complex. Fundamemtally spark promotes re-computation over global shared memory. So, perhaps, you could store partially computed data/result in another store like HDFS/Kafka/cassandra!!!

Answer 3

Have a look at ByteBuffer.allocateDirect(int bytes) . You don't need to memory map files to make use of them.

Off heap can be a good choice if the objects will stick there for a while (ie are reused). If you'll be allocating/deallocating them as you go, that's going to be slower.

Unsafe is cool but it's going to be removed . Probably in Java 9.