Java直接内存读写的例子

在Hotspot JVM上，我们能够直接对内存进行读写操作。该类的allocateMemory方法用于申请分配内存，putAddress和getAddress方法用于对直接内存进行读写。

本文将通过sun.misc.Unsafe给出一个直接读写内存的例子。

注意：这只是一个例子，只是用来验证通过sun.misc.Unsafe来实现直接读写内存的可能性。但是，这样做并没有安全保证，而且稍微有点疏忽将可能导致JVM崩溃。

Unsafe类的三个方法：allocateMemory，putAddress和getAddress如下：

1. /**
2. * Fetches a native pointer from a given memory address.  If the address is
3. * zero, or does not point into a block obtained from {@link
4. * #allocateMemory}, the results are undefined.
5. *
6. * <p> If the native pointer is less than  bits wide, it is extended as
7. * an unsigned number to a Java long.  The pointer may be indexed by any
8. * given byte offset, simply by adding that offset (as a simple integer) to
9. * the long representing the pointer.  The number of bytes actually read
10. * from the target address maybe determined by consulting {@link
11. * #addressSize}.
12. *
13. * @see #allocateMemory
14. */
15. public native long getAddress(long address);
16. /**
17. * Stores a native pointer into a given memory address.  If the address is
18. * zero, or does not point into a block obtained from {@link
19. * #allocateMemory}, the results are undefined.
20. *
21. * <p> The number of bytes actually written at the target address maybe
22. * determined by consulting {@link #addressSize}.
23. *
24. * @see #getAddress(long)
25. */
26. public native void putAddress(long address, long x);
27. /// wrappers for malloc, realloc, free:
28. /**
29. * Allocates a new block of native memory, of the given size in bytes.  The
30. * contents of the memory are uninitialized; they will generally be
31. * garbage.  The resulting native pointer will never be zero, and will be
32. * aligned for all value types.  Dispose of this memory by calling {@link
33. * #freeMemory}, or resize it with {@link #reallocateMemory}.
34. *
35. * @throws IllegalArgumentException if the size is negative or too large
36. *         for the native size_t type
37. *
38. * @throws OutOfMemoryError if the allocation is refused by the system
39. *
40. * @see #getByte(long)
41. * @see #putByte(long, byte)
42. */
43. public native long allocateMemory(long bytes);

1. long allocateMemory(long bytes) 
申请分配内存 
2. long getAddress(long address) 和void putAddress(long address, long x) 
对直接内存进行读写。

因为Unsafe这个类的访问是受限的，只有rt.jar中的类才能使用Unsafe的功能，它的构造方法是私有的，所以，我们不能通过new来创建实例。但是，可以通过反射的方法来获取Unsafe实例。

下面就是一个直接访问内存的一个例子：

1. import java.lang.reflect.Field;
2. import sun.misc.Unsafe;
3. public class DirectMemoryAccess {
4. public static void main(String[] args) {
5. /*
6. * Unsafe的构造函数是私有的，不能通过new来获得实例。
7. *
8. *  通过反射来获取
9. */
10. Unsafe unsafe = null;
11. Field field = null;
12. try {
13. field = sun.misc.Unsafe.class.getDeclaredField("theUnsafe");
14. /*
15. * private static final Unsafe theUnsafe = new Unsafe();
16. *
17. * 因为field的修饰符为 private static final,
18. * 需要将setAccessible设置成true，否则会报java.lang.IllegalAccessException
19. */
20. field.setAccessible(true);
21. unsafe = (Unsafe) field.get(null);
22. } catch (SecurityException e) {
23. // TODO Auto-generated catch block
24. e.printStackTrace();
25. } catch (NoSuchFieldException e) {
26. // TODO Auto-generated catch block
27. e.printStackTrace();
28. } catch (IllegalArgumentException e) {
29. // TODO Auto-generated catch block
30. e.printStackTrace();
31. } catch (IllegalAccessException e) {
32. // TODO Auto-generated catch block
33. e.printStackTrace();
34. }
35. long oneHundred = 100;
36. byte size = 1;
37. /*
38. * 调用allocateMemory分配内存
39. */
40. long memoryAddress = unsafe.allocateMemory(size);
41. /*
42. * 将100写入到内存中
43. */
44. unsafe.putAddress(memoryAddress, oneHundred);
45. /*
46. * 内存中读取数据
47. */
48. long readValue = unsafe.getAddress(memoryAddress);
49. System.out.println("Val : " + readValue);
50. }
51. }

输出结果： 
Val : 100

如果，想要查阅Unsafe的源代码，请参考下面的链接. 
http://www.docjar.com/html/api/sun/misc/Unsafe.java.html

原文 转自 ：http://blog.csdn.net/joe_007/article/details/38964407