都知道NIO在读取大文件的时候都比较快。但是在小文件的写入就不是这样了（这个例子源于使用1G的内存如何找到10G大小的文件出现频率最高的数字，后来觉得NIO读写大文件有优势，那么小文件读写也应该比较快吧！）。

下面是一个使用NIO来像文件写入String的例子：

package nio;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class NIOWriter {

    private FileChannel fileChannel;
    private ByteBuffer buf;

    @SuppressWarnings("resource")
    public NIOWriter(File file, int capacity) {
        try {
            TimeMonitor.start();
            fileChannel = new FileOutputStream(file).getChannel();
            TimeMonitor.end("fileChannel = new FileOutputStream(file).getChannel()");
            buf = ByteBuffer.allocate(capacity);

        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    /**
     * 不采用递归是因为如果字符串过大而缓存区过小引发StackOverflowException
     * 
     * @param str
     * @throws IOException
     */
    public void write(String str) throws IOException {
        TimeMonitor.start();
        int length = str.length();
        byte[] bytes = str.getBytes();
        int startPosition = 0;
        do {
            startPosition = write0(bytes, startPosition);
        } while (startPosition < length);
        TimeMonitor.end("write(String str)");
    }

    public int write0(byte[] bytes, int position) throws IOException {
        if (position >= bytes.length) {
            return position;
        }
        while (buf.hasRemaining()) {
            if (position < bytes.length) {
                buf.put(bytes[position]);
                position++;
            } else {
                break;
            }
        }
        buf.flip();
        fileChannel.write(buf);

        buf.clear();
        return position;
    }
    /**
     * 强制写入数据。并且关闭连接
     */
    public void close() {
        try {
            fileChannel.close();
        } catch (IOException e) {

            e.printStackTrace();
        }
    }    
}

然后使用JMH与其他小文件写入方式来作比较。按理说，使用NIO的方式每次都有缓存，速度应该会很快，但实际却不是这样。下面做了一个比较，分别使用FileWriter，buffer，直接写，以及NIO的方式：

package nio;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.util.concurrent.TimeUnit;

import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;

public class WriterTest {

    static int writeCount = 1;
    static String inputStr = "very woman is a" + " treasure but way too often we forget"
            + " how precious they are. We get lost in daily "
            + "chores and stinky diapers, in work deadlines and dirty dishes, in daily errands and occasional breakdowns.";

    public static void main(String[] args) throws Exception {
        Options opt = new OptionsBuilder().include(WriterTest.class.getSimpleName()).forks(1).build();
        new Runner(opt).run();

    }

    @Benchmark
    @BenchmarkMode(Mode.SingleShotTime)
    @OutputTimeUnit(TimeUnit.MILLISECONDS)
    public void TestFileWriter() throws IOException {
        File file = new File("/Users/xujianxing/Desktop/fileWithWriter.txt");
        FileWriter fileWriter = new FileWriter(file);
        for (int i = 0; i < writeCount; i++) {
            fileWriter.write("JAVA TEST");
        }

    }

    @Benchmark
    @BenchmarkMode(Mode.SingleShotTime)
    @OutputTimeUnit(TimeUnit.MILLISECONDS)
    public void TestBuffer() throws IOException {
        File file = new File("/Users/xujianxing/Desktop/buffer.txt");
        BufferedOutputStream buffer = new BufferedOutputStream(new FileOutputStream(file));
        for (int i = 0; i < writeCount; i++) {
            buffer.write(inputStr.getBytes());
        }
        buffer.flush();
        buffer.close();
    }

    @Benchmark
    @BenchmarkMode(Mode.SingleShotTime)
    @OutputTimeUnit(TimeUnit.MILLISECONDS)
    public void TestNormal() throws IOException {
        File file = new File("/Users/xujianxing/Desktop/normal.txt");
        FileOutputStream out = new FileOutputStream(file);
        for (int i = 0; i < writeCount; i++) {
            out.write(inputStr.getBytes());

        }
        out.close();

    }

    @Benchmark
    @BenchmarkMode(Mode.SingleShotTime)
    @OutputTimeUnit(TimeUnit.MILLISECONDS)
    public void TestNIO() throws IOException {
        File file = new File("/Users/xujianxing/Desktop/nio.txt");
        NIOWriter nioWriter = new NIOWriter(file, 2048);
        for (int i = 0; i < writeCount; i++) {
            nioWriter.write(inputStr);

        }
       nioWriter.close();

    }

}

然而测试的结果却大跌眼镜，看一看测试的结果：

Benchmark                  Mode  Cnt  Score   Error  Units
WriterTest.TestBuffer        ss       0.265          ms/op
WriterTest.TestFileWriter    ss       0.232          ms/op
WriterTest.TestNIO           ss       8.479          ms/op
WriterTest.TestNormal        ss       0.217          ms/op

NIO的测试结果是最差的，结果却花了8ms之多！而且写次数越多，差距越大。

这到底是为什么呢？

写了一个简单的测试类来记录花费的时间：

package nio;

public class TimeMonitor {
    private static long start = 0;

    private static long end = 0;

    public static void start() {

        start = System.currentTimeMillis();
        end = 0;

    }

    public static void end(String  tag) {
        end = System.currentTimeMillis();
        System.out.println("time  coast:"+tag+"---------->" + (end - start));
        end = 0;
        start = 0;
    }

}

然后在觉得可能会耗时的地方上（比如channel的获得，channel的写入等）输出结果是这样的：

time  coast:fileChannel = new FileOutputStream(file).getChannel()---------->5
time  coast:write0---------->0
time  coast:fileChannel.write(buf)---------->2

从输出的结果看，果然是在创建channel的时候已经写channel的时候花费了大量的时间。但是多余的一毫秒多哪去了？

改正一下测试类，结果是这样的：

@Benchmark
    @BenchmarkMode(Mode.SingleShotTime)
    @OutputTimeUnit(TimeUnit.MILLISECONDS)
    public void TestNIO() throws IOException {
        TimeMonitor.start();
        File file = new File("/Users/xujianxing/Desktop/nio.txt");
        NIOWriter nioWriter = new NIOWriter(file, 2048);
//        TimeMonitor.end("NIOWriter nioWriter = new NIOWriter(file, 2048);");
        for (int i = 0; i < writeCount; i++) {
//            TimeMonitor.start();
            nioWriter.write(inputStr);
//            TimeMonitor.end("nioWriter.write(inputStr)");
        }
//        TimeMonitor.start();
        nioWriter.close();
        TimeMonitor.end("    nioWriter.close()");
    }

}

输出结果是这样的(不同的机器可能会不一样，每次耗费的时间也不一样）：

 time  coast:    nioWriter.close()---------->6

发现，耗费多出的1毫秒多应该是JMH自己本身耗费的时间。但奇怪的是测试其他普通方式读写却没有发现这种情况，为什么会这样尚不得而知。不过，不要使用NIO读取小文件肯定是正确的。