欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识！
您现在的位置是： 首页

加快Java的文件序列化速度  

程序员文章站 2022-05-03 20:56:50
...

转自：http://www.oschina.net/question/100267_72178

自从第一个Java版本开始，很多开发人员一直都在尝试让Java获得最少和C/C++一样的表现。JVM提供商尽他们最大的努力去实现一些新的JIT算法，但是还是有很多需要做的，特别是在我们使用Java的方法上。

例如，在对象<->文件序列化上就差距很大--尤其在读写内存对象上。我将就这个主题做一些解释和分享。

所有的测试都是在下面这个对象上执行的：

1 public class TestObject implements Serializable {
2  
3   private long longVariable;
4   private long[] longArray;
5   private String stringObject;
6   private String secondStringObject; //just for testing nulls
7  
8   /* getters and setters */
9 }

 

 

为了简单起见，我将只贴出写入方法（尽管读取类似），完整的源码在我的GitHub上可以找到（http://github.com/jkubrynski/serialization-tests）

最标准的java序列化（我们都是从这里学起的）是这样的：

01 public void testWriteBuffered(TestObject test, String fileName) throwsIOException {
02   ObjectOutputStream objectOutputStream = null;
03   try {
04     FileOutputStream fos = new FileOutputStream(fileName);
05     BufferedOutputStream bos = new BufferedOutputStream(fos);
06     objectOutputStream = new ObjectOutputStream(bos);
07     objectOutputStream.writeObject(test);
08   } finally {
09     if (objectOutputStream != null) {
10       objectOutputStream.close();
11     }
12   }
13 }

 

 

提升标准序列化速度的最简单方法时使用RandomAccessFile对象：

01 public void testWriteBuffered(TestObject test, String fileName) throwsIOException {
02   ObjectOutputStream objectOutputStream = null;
03   try {
04     RandomAccessFile raf = new RandomAccessFile(fileName, "rw");
05     FileOutputStream fos = new FileOutputStream(raf.getFD());
06     objectOutputStream = new ObjectOutputStream(fos);
07     objectOutputStream.writeObject(test);
08   } finally {
09     if (objectOutputStream != null) {
10       objectOutputStream.close();
11     }     
12 }

 

 

更高深点的技术是使用Kryo框架，新旧版本的差距是很大的，我做过测试。因为性能比较上并没有体现出特别引人注意的差异，所以我将使用2.x版本，因为它对用户更友好而且更快些。

01 private static Kryo kryo = new Kryo(); // version 2.x
02  
03 public void testWriteBuffered(TestObject test, String fileName) throwsIOException {
04   Output output = null;
05   try {
06     RandomAccessFile raf = new RandomAccessFile(fileName, "rw");
07     output = new Output(new FileOutputStream(raf.getFD()), MAX_BUFFER_SIZE);
08     kryo.writeObject(output, test);
09   } finally {
10     if (output != null) {
11       output.close();
12     }
13   }
14 }

 

 

最后一个方案是在Martin Thompson的文章中提到的（Native C/C++ Like Performance For Java Object Serialisation），介绍了怎样在Java中像C++那样和内存打交道。

01 public void testWriteBuffered(TestObject test, String fileName) throwsIOException {
02   RandomAccessFile raf = null;
03   try {
04     MemoryBuffer memoryBuffer = new MemoryBuffer(MAX_BUFFER_SIZE);
05     raf = new RandomAccessFile(fileName, "rw");
06     test.write(memoryBuffer);
07     raf.write(memoryBuffer.getBuffer());
08   } catch (IOException e) {
09     if (raf != null) {
10       raf.close();
11     }
12   }
13 }

 

 

TestObject写入方法如下：

01 public void write(MemoryBuffer unsafeBuffer) {
02   unsafeBuffer.putLong(longVariable);
03   unsafeBuffer.putLongArray(longArray);
04   // we support nulls
05   boolean objectExists = stringObject != null;
06   unsafeBuffer.putBoolean(objectExists);
07   if (objectExists) {
08     unsafeBuffer.putCharArray(stringObject.toCharArray());
09   }
10   objectExists = secondStringObject != null;
11   unsafeBuffer.putBoolean(objectExists);
12   if (objectExists) {
13     unsafeBuffer.putCharArray(secondStringObject.toCharArray());
14   }
15 }

 

 

直接内存缓冲区类（已简化了的，仅仅为了展示这个思想）

01 public class MemoryBuffer {
02   // getting Unsafe by reflection
03   public static final Unsafe unsafe = UnsafeUtil.getUnsafe();
04  
05   private final byte[] buffer;
06  
07   private static final longbyteArrayOffset = unsafe.arrayBaseOffset(byte[].class);
08   private static final longlongArrayOffset = unsafe.arrayBaseOffset(long[].class);
09   /* other offsets */
10  
11   private static final int SIZE_OF_LONG = 8;
12   /* other sizes */
13  
14   private long pos = 0;
15  
16   public MemoryBuffer(int bufferSize) {
17     this.buffer = new byte[bufferSize];
18   }
19  
20   public final byte[] getBuffer() {
21     return buffer;
22   }
23  
24   public final void putLong(long value) {
25     unsafe.putLong(buffer, byteArrayOffset + pos, value);
26     pos += SIZE_OF_LONG;
27   }
28  
29   public final long getLong() {
30     long result = unsafe.getLong(buffer, byteArrayOffset + pos);
31     pos += SIZE_OF_LONG;
32     return result;
33   }
34  
35   public final void putLongArray(final long[] values) {
36     putInt(values.length);
37     long bytesToCopy = values.length << 3;
38     unsafe.copyMemory(values, longArrayOffset, buffer, byteArrayOffset + pos, bytesToCopy);
39     pos += bytesToCopy;
40   }
41  
42  
43   public final long[] getLongArray() {
44     int arraySize = getInt();
45     long[] values = new long[arraySize];
46     long bytesToCopy = values.length << 3;
47     unsafe.copyMemory(buffer, byteArrayOffset + pos, values, longArrayOffset, bytesToCopy);
48     pos += bytesToCopy;
49     return values;
50   }
51  
52   /* other methods */
53 }

 

 

几个小时的Caliper测试结果如下：

 

  Full trip [ns]  Standard deviation [ns] 
Standard   207307  2362
Standard on RAF  42661  733
KRYO 1.x   12027  112
KRYO 2.x  11479  259
Unsafe  8554  91

 

在最后我们可以得出一些结论：

  • Unsafe序列化比标准的java.io.Serizlizable快了23倍
  • 使用RandomAccessFile可以使标准的有缓冲序列化加速将近4倍
  • Kryo-dynamic序列化大约比手写实现的直接缓冲满了35%

最后，就像我们看到的那样，还是没有绝对的答案。对于我们中的大多数人来说，获得3000ns(0.003ms)的速度提升是不值得为每个需要序列化的对象来写单独实现的。在标准的方案中，我们大多数选择Kryo 。然而，在惜时如金的低延时系统中，这个选择将会是完全不同的。

上一篇： image.png 我顿时觉得**一紧，仔细回顾一下，如果wait()方法不在同步块中，代码的确会抛出IllegalMonitorStateExeception:

下一篇： HTML5做的一个小动画有个奇葩的问题._html/css_WEB-ITnose

推荐阅读