Java Direct Memory read and write examples

On the hotspot JVM, we are able to read and write directly to the memory. The Allocatememory method of this class is used to request the allocation of memory, and the Putaddress and GetAddress methods are used to read and write direct memory.

This article will give an example of direct read and write memory through Sun.misc.Unsafe.

Note: This is only an example of the possibility of using Sun.misc.Unsafe to read and write memory directly. However, there is no security guarantee, and a bit of negligence can cause the JVM to crash.

The three methods of the unsafe class: Allocatememory,putaddress and GetAddress are as follows:

Java code

2. /**
4. * Fetches a native pointer from a given memory address. If the address is
6. * Zero, or does not point to a block obtained from {@link
8. * #allocateMemory}, the results is undefined.
10. *
12. * <p> If The native pointer is less than bits wide, it's extended as
14. * A unsigned number to a Java long. The pointer is indexed by any
16. * Given byte offset, simply by adding this offset (as a simple integer) to
18. * The long representing the pointer. The number of bytes actually read
20. * from the target address maybe determined by consulting {@link
22. * #addressSize}.
24. *
26. * @see #allocateMemory
28. */
30. public native long getaddress (long address);
34. /** 
36. * Stores A native pointer into a given memory address. If the address is
38. * Zero, or does not point to a block obtained from {@link
40. * #allocateMemory}, the results is undefined.
42. *
44. * <p> the number of bytes actually written at the target address maybe
46. * Determined by consulting {@link #addressSize}.
48. *
50. * @see #getAddress (Long)
52. */
54. public native void putaddress (long address, long x);
58. //wrappers for malloc, realloc, free:
62. /** 
64. * Allocates a new block of native memory, of the given size in bytes. The
66. * Contents of the memory is uninitialized; They'll generally be
68. * Garbage. The resulting native pointer would never be zero, and would be
70. * aligned for all value types. Dispose of this memory by calling {@link
72. * #freeMemory}, or resize it with {@link #reallocateMemory}.
74. *
76. * @throws IllegalArgumentException If the size is negative or too large
78. * For the native size_t type
80. *
82. * @throws OutOfMemoryError If the allocation is refused by the system
84. *
86. * @see #getByte (Long)
88. * @see #putByte (long, byte)
90. */
92. public native long allocatememory (long bytes);

1. Long allocatememory (long bytes)
Request to allocate memory
2. Long getaddress (long address) and void putaddress (long address, long X)
Read and write to direct memory.


because the access to this class is restricted, only classes in Rt.jar can use the unsafe function, and its construction method is private, so we cannot create an instance from new. However, an unsafe instance can be obtained by means of reflection.

Here is an example of a direct memory access:

Java code

2. Import Java.lang.reflect.Field;
6. Import Sun.misc.Unsafe;
10. Public class Directmemoryaccess {
14. public static void Main (string[] args) {
18. /* 
20. * Unsafe's constructor is private and cannot be obtained by new.
22. *
24. * Through reflection to get
26. */
28. unsafe unsafe = null;
30. Field field = null;
32. try {
34. field = Sun.misc.Unsafe.  Class.getdeclaredfield ("Theunsafe");
36. /* 
38. * Private static final unsafe Theunsafe = new unsafe ();
40. *
42. * Because the field modifier is private static final,
44. * Setaccessible must be set to true, otherwise it will be reported java.lang.IllegalAccessException
46. */
48. Field.setaccessible (true);
50. unsafe = (unsafe) field.get (null);
52. } catch (SecurityException e) {
54. //TODO auto-generated catch block
56. E.printstacktrace ();
58. } catch (Nosuchfieldexception e) {
60. //TODO auto-generated catch block
62. E.printstacktrace ();
64. } catch (IllegalArgumentException e) {
66. //TODO auto-generated catch block
68. E.printstacktrace ();
70. } catch (Illegalaccessexception e) {
72. //TODO auto-generated catch block
74. E.printstacktrace ();
76. }
80. long onehundred = 100;
82. byte size = 1;
86. /* 
88. * Call Allocatememory to allocate memory
90. */
92. Long memoryaddress = unsafe.allocatememory (size);
96. /* 
98. * Write 100 to Memory
100. */
102. Unsafe.putaddress (memoryaddress, onehundred);
106. /* 
108. * Read data in memory
110. */
112. Long readvalue = unsafe.getaddress (memoryaddress);
116. System.out.println ("Val:" + readvalue);
118. }
120. }

Output Result:
val:100

If you would like to consult the source code of unsafe, please refer to the link below.
Http://www.docjar.com/html/api/sun/misc/Unsafe.java.html

Translated from: http://blog.csdn.net/joe_007/article/details/38964407

Java Direct Memory read and write examples