File Serialization的加速度

File读写是我们经常对于File处理经常需要动作，接下来我会用4中方式进行操作，具体在项目中采用哪一种方式，由自己进行判断。

最近在Thomas Nagel《What Does It All Mean》，摘录开头一段话：

要评估每一种主张，每一条论证和每一套理论，并且尝试着判断它们是否可以被接受，这最终都依赖于每一个人的独立思考，而非听命于权威

2B青年方式：

  private static class StandardSerialization implements SerializationTest {
    public void testWriteBuffered(TestObject test, String fileName) throws IOException {
      ObjectOutputStream objectOutputStream = null;
      try {
        FileOutputStream fileOutputStream = new FileOutputStream(fileName);
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
        objectOutputStream = new ObjectOutputStream(bufferedOutputStream);
        objectOutputStream.writeObject(test);
      } finally {
        if (objectOutputStream != null) {
          objectOutputStream.close();
        }
      }
    }

    public TestObject testReadBuffered(String fileName) throws IOException, ClassNotFoundException {
      ObjectInputStream objectInputStream = null;
      try {
        FileInputStream fileInputStream = new FileInputStream(fileName);
        BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
        objectInputStream = new ObjectInputStream(bufferedInputStream);
        return (TestObject) objectInputStream.readObject();
      } finally {
        if (objectInputStream != null) {
          objectInputStream.close();
        }
      }
    }
  }

 普通青年：

private static class StandardSerializationRaf implements SerializationTest {
    public void testWriteBuffered(TestObject test, String fileName) throws IOException {
      ObjectOutputStream objectOutputStream = null;
      try {
        RandomAccessFile randomAccessFile = new RandomAccessFile(fileName, FILE_MODE_RW);
        FileOutputStream fileOutputStream = new FileOutputStream(randomAccessFile.getFD());
        objectOutputStream = new ObjectOutputStream(fileOutputStream);
        objectOutputStream.writeObject(test);
      } finally {
        if (objectOutputStream != null) {
          objectOutputStream.close();
        }
      }
    }

    public TestObject testReadBuffered(String fileName) throws IOException, ClassNotFoundException {
      ObjectInputStream objectInputStream = null;
      try {
        RandomAccessFile randomAccessFile = new RandomAccessFile(fileName, FILE_MODE_R);
        FileInputStream fileInputStream = new FileInputStream(randomAccessFile.getFD());
        objectInputStream = new ObjectInputStream(fileInputStream);
        return (TestObject) objectInputStream.readObject();
      } finally {
        if (objectInputStream != null) {
          objectInputStream.close();
        }
      }
    }
  }

 文艺青年：

采用Kryo Framework

  private static class Kryo2Serialization implements SerializationTest {

    private static Kryo kryo = new Kryo();

    public void testWriteBuffered(TestObject test, String fileName) throws IOException {
      Output output = null;
      try {
        RandomAccessFile raf = new RandomAccessFile(fileName, "rw");
        output = new Output(new FileOutputStream(raf.getFD()), MAX_BUFFER_SIZE);
        kryo.writeObject(output, test);
      } finally {
        if (output != null) {
          output.close();
        }
      }
    }

    public TestObject testReadBuffered(String fileName) throws IOException {
      Input input = null;
      try {
        RandomAccessFile raf = new RandomAccessFile(fileName, "r");
        input = new Input(new FileInputStream(raf.getFD()), MAX_BUFFER_SIZE);
        return kryo.readObject(input, TestObject.class);
      } finally {
        if (input != null) {
          input.close();
        }
      }

    }
  }

 Geeker：

  private static class DirectSerialization implements SerializationTest {
    public void testWriteBuffered(TestObject test, String fileName) throws IOException {
      RandomAccessFile raf = null;
      try {
        MemoryBuffer memoryBuffer = new MemoryBuffer(MAX_BUFFER_SIZE);
        raf = new RandomAccessFile(fileName, FILE_MODE_RW);
        test.write(memoryBuffer);
        raf.write(memoryBuffer.getBuffer());
      } finally {
        if (raf != null) {
          raf.close();
        }
      }
    }

    public TestObject testReadBuffered(String fileName) throws IOException {
      RandomAccessFile raf = null;
      try {
        raf = new RandomAccessFile(fileName, FILE_MODE_R);
        MemoryBuffer unsafeBuffer = new MemoryBuffer((int) raf.length());
        raf.read(unsafeBuffer.getBuffer());
        return TestObject.read(unsafeBuffer);
      } finally {
        if (raf != null) {
          raf.close();
        }
      }
    }
  }

 最终输出的结果是：

 结论：

RandomAccessFile确实提高很明显

Kryo-dynamic serialization在write的时候优势明显，读取相差无几

UNSAFE_MEMORY确实高效，不过容易Memory Leak