How and Why Unsafe is Used in Java---reference
By Peter Lawrey
https://www.voxxed.com/blog/2014/12/how-and-why-unsafe-is-used-in-java/
Overview
sun.misc.Unsafe has been in Java from at least as far back as Java 1.4 (2004). In Java 9, Unsafe will be hidden along with many other, for-internal-use classes. to improve the maintainability of the JVM. While it is still unclear exactly what will replace Unsafe, and I suspect it will be more than one thing which replaces it, it raises the question, why is it used at all?
Doing things which the Java language doesn’t allow but are still useful.
Java doesn’t allow many of the tricks which are available to lower level languages. For most developers this is very good thing, and it not only saves you from yourself, it also saves you from your co-workers. It also makes it easier to import open source code because you know there is limits to how much damage they can do. Or at least there is limits to how much you can do accidentally. If you try hard enough you can still do damage.
But why would you even try, you might wonder? When building libraries many (but not all) of the methods in Unsafe are useful and in some cases, there is no other way to do the same thing without using JNI, which is even more dangerous and you lose the “compile once, run anywhere”
Deserialization of objects
1
2
3
4
5
6
7
8
9
10
11
|
public class A implements Serializable { private final int num; public A( int num) { System.out.println( "Hello Mum" ); this .num = num; } public int getNum() { return num; } } |
In this class, you should be able to rebuild and set the final field, but if you have to call a constructor and it might do things which don’t have anything to do with deserialization. For these reasons many libraries use Unsafe to create instances without calling a constructor
1
2
3
|
Unsafe unsafe = getUnsafe(); Class aClass = A. class ; A a = (A) unsafe.allocateInstance(aClass); |
Calling allocateInstance avoids the need to call the appropriate constructor, when we don’t need one.
Thread safe access to direct memory
Another use for Unsafe is thread safe access to off heap memory. ByteBuffer gives you safe access to off heap or direct memory, however it doesn’t have any thread safe operations. This is particularly useful if you want to share data between processes.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
|
import sun.misc.Unsafe; import sun.nio.ch.DirectBuffer; import java.io.File; import java.io.IOException; import java.io.RandomAccessFile; import java.lang.reflect.Field; import java.nio.MappedByteBuffer; import java.nio.channels.FileChannel; public class PingPongMapMain { public static void main(String... args) throws IOException { boolean odd; switch (args.length < 1 ? "usage" : args[ 0 ].toLowerCase()) { case "odd" : odd = true ; break ; case "even" : odd = false ; break ; default : System.err.println( "Usage: java PingPongMain [odd|even]" ); return ; } int runs = 10000000 ; long start = 0 ; System.out.println( "Waiting for the other odd/even" ); File counters = new File(System.getProperty( "java.io.tmpdir" ), "counters.deleteme" ); counters.deleteOnExit(); try (FileChannel fc = new RandomAccessFile(counters, "rw" ).getChannel()) { MappedByteBuffer mbb = fc.map(FileChannel.MapMode.READ_WRITE, 0 , 1024 ); long address = ((DirectBuffer) mbb).address(); for ( int i = - 1 ; i < runs; i++) { for (; ; ) { long value = UNSAFE.getLongVolatile( null , address); boolean isOdd = (value & 1 ) != 0 ; if (isOdd != odd) // wait for the other side. continue ; // make the change atomic, just in case there is more than one odd/even process if (UNSAFE.compareAndSwapLong( null , address, value, value + 1 )) break ; } if (i == 0 ) { System.out.println( "Started" ); start = System.nanoTime(); } } } System.out.printf( "... Finished, average ping/pong took %,d ns%n" , (System.nanoTime() - start) / runs); } static final Unsafe UNSAFE; static { try { Field theUnsafe = Unsafe. class .getDeclaredField( "theUnsafe" ); theUnsafe.setAccessible( true ); UNSAFE = (Unsafe) theUnsafe.get( null ); } catch (Exception e) { throw new AssertionError(e); } } } |
When you run this in two programs, one with odd and the other with even. You can see that each process is changing data via persisted shared memory.
In each program it maps the same are of the disks cache into the process. There is actually only one copy of the file in memory. This means the memory can be shared, provided you use thread safe operations such as the volatile and CAS operations.
The output on an i7-3970X is
Waiting for the other odd/even
Started
… Finished, average ping/pong took 83 ns
That is 83 ns round trip time between two processes. When you consider System V IPC takes around 2,500 ns and IPC volatile instead of persisted, that is pretty quick.
Is using Unsafe suitable for work?
Conclusion
相关文章
- Java实现 LeetCode 8 字符串转换整数(atoi)
- java实现 猜数字游戏
- Java实现第八届蓝桥杯方格分割
- Java实现 蓝桥杯VIP 算法提高 字符串比较
- java mongodb 基础系列---查询,排序,limit,$in,$or,输出为list,创建索引,$ne 非操作
- 【JAVA】 03-Java中的异常和包的使用
- JAVA编程思想读书笔记(五)--多线程
- 【JAVA】Java 异常中e的getMessage()和toString()方法的异同
- 【JAVA】java中的length和length()
- [Linux] Install java and add JAVA_HOME, PATH
- 【Java】java使用反射访问对象方法和成员变量
- DEFAULT keyword in ABAP and Optional Class in Java
- Atitit java jsp 新的tag技术
- Atitit. Exception in thread "main" java.lang.Error: Unresolved compilation problem:
- Error:Execution failed for task ‘:app:transformNative_libsWithStripDebugSymbolForDebug‘.> java.io.IO
- Matlab:成功解决In an assignment A(I)=B,the number of elements in B and I must be the same
- Java中String类的concat方法___java的String字符串的concat()方法连接字符串和“+“连接字符串解释
- Java如何获取IP属地 ip2region failed to create searcher with x:java.io.FileNotFoundException:( 系统找不到指定的路径)
- Java 异常解决之java.lang.IllegalArgumentException: Comparison method violates its general contract!
- Java Web系统经常使用的第三方接口