Why did I find that it was not faster than javaio after testing?

[guangmomo]

okio code

        Source source = null;
        BufferedSource bufferedSource = null;
        source = Okio.source(new File("zip1/SynalyzeItProTA_1.23.2.zip"));
        bufferedSource = Okio.buffer(source);
        Sink sink = null;
        BufferedSink bufferedSink = null;
        sink = Okio.sink(new File("zip2/1.zip"));
        bufferedSink = Okio.buffer(sink);
        int bufferSize = 8192; // 8kb
        long begin = System.currentTimeMillis();
        while (!bufferedSource.exhausted()) {
            bufferedSource.read(
                    bufferedSink.buffer(),
                    bufferSize
            );
            bufferedSink.emit();
        }
        System.out.println("timeIs：" + (System.currentTimeMillis() - begin)); 
        source.close();
        sink.close();

javaio code

        FileInputStream in = new FileInputStream("zip1/SynalyzeItProTA_1.23.2.zip");
        BufferedInputStream inBuffer = new BufferedInputStream(in);
        FileOutputStream out = new FileOutputStream("zip2/1.zip");
        BufferedOutputStream outBuffer = new BufferedOutputStream(out);
        int len = 0;
        byte[] bs = new byte[8192];
        long begin = System.currentTimeMillis();
        while ((len = inBuffer.read(bs)) != -1) {
            outBuffer.write(bs, 0, len);
        }
        System.out.println("timeIs" + (System.currentTimeMillis() - begin)); 
        inBuffer.close();
        in.close();
        outBuffer.close();
        out.close();

okio time is : 124ms
javaio time is: 77ms

[JakeWharton]

You're calling emit() inside the loop for Okio and there is no equivalent in java.io.

Given a BufferedSource and BufferedSink, the entire code could be replaced with source.readAll(sink).

[guangmomo]

You're calling emit() inside the loop for Okio and there is no equivalent in java.io.

Given a BufferedSource and BufferedSink, the entire code could be replaced with source.readAll(sink).

I use

Okio.buffer(Okio.sink(new File("zip2/1.zip"))).writeAll(Okio.buffer(Okio.source(new File("zip1/SynalyzeItProTA_1.23.2.zip"))));

and then time is 117ms
I use okio 1.13.0

[JakeWharton]

Don't know then. You'd have to dig in with a profiler. Both wind up doing the same thing though.

[guangmomo]

Don't know then. You'd have to dig in with a profiler. Both wind up doing the same thing though.

At first I thought that Okio had two copies less than java.io, so it would be faster.
Okio emit() Equivalent to java.io flushBuffer() ?

[guangmomo]

You're calling emit() inside the loop for Okio and there is no equivalent in java.io.

Given a BufferedSource and BufferedSink, the entire code could be replaced with source.readAll(sink).

If the file is large, source.readAll(sink) will cause OOM
I want to use Okio to optimize the speed, but it is very strange that Okio is slower.
I think that Okio is too complicated Buffer operation is slower than copying java.io array

[bnorm]

If the file is large, source.readAll(sink) will cause OOM

If you can create a small code example which can reproduce this reliably, I would be very interested.

As for why Okio is slower, a couple comments:

• It looks like you are testing against the file system. This doesn't do a good job at isolating okio or java.io performance characteristics. I've run your sample code multiple times and saw wildly fluctuating numbers.
• Okio.sink(file) has to use a FileOutputStream as that is the lowest level Java allows for file IO. Same goes for Okio.source(file).
• BufferedInputStream actually has an optimization to skip the internal buffer if the supplied byte[] is greater than or equal in size. The same goes for BufferedOutputStream. Your intermediate byte[] is the same size as the internal buffers so in theory you are skipping the java.io buffering layer.

[guangmomo]

If the file is large, source.readAll(sink) will cause OOM

If you can create a small code example which can reproduce this reliably, I would be very interested.

As for why Okio is slower, a couple comments:

• It looks like you are testing against the file system. This doesn't do a good job at isolating okio or java.io performance characteristics. I've run your sample code multiple times and saw wildly fluctuating numbers.
• Okio.sink(file) has to use a FileOutputStream as that is the lowest level Java allows for file IO. Same goes for Okio.source(file).
• BufferedInputStream actually has an optimization to skip the internal buffer if the supplied byte[] is greater than or equal in size. The same goes for BufferedOutputStream. Your intermediate byte[] is the same size as the internal buffers so in theory you are skipping the java.io buffering layer.

        String ex = Environment.getExternalStorageDirectory().getAbsolutePath();
        Source source = null;
        BufferedSource bufferedSource = null;
        source = Okio.source(new File(ex + "/1/1.zip"));
        bufferedSource = Okio.buffer(source);
        Sink sink = null;
        BufferedSink bufferedSink = null;
        sink = Okio.sink(new File(ex + "/2/2.zip"));
        bufferedSink = Okio.buffer(sink);
        while (!bufferedSource.exhausted()) {
            bufferedSource.readAll(
                    bufferedSink.getBuffer());
            bufferedSink.emit();
        }
        source.close();
        sink.close();

1.zip size is 1GB，When I ran the code on my Android phone, I triggered OOM.
I looked at the source code and found that readAll will read the entire file into memory, and then write it to disk after reading it, thus causing OOM

[JakeWharton]

Okio isn't doing that. You are doing that by reading into the buffer instead of directly into the sink.

[guangmomo]

Okio isn't doing that. You are doing that by reading into the buffer instead of directly into the sink.

thanks, So what is the correct readAll way?

[JakeWharton]

Replace the while loop with bufferedSource.readAll(bufferedSink);. Change the close() calls to operate on bufferedSource and bufferedSink (so that the latter triggers flush).

[guangmomo]

Replace the while loop with bufferedSource.readAll(bufferedSink);. Change the close() calls to operate on bufferedSource and bufferedSink (so that the latter triggers flush).

your code

        bufferedSource.readAll(bufferedSink);
        source.close();
        sink.close();

Equivalent to the code I wrote at the beginning, as follows

        while (!bufferedSource.exhausted()) {
            bufferedSource.read(
                    bufferedSink.getBuffer(), bufferSize);
            bufferedSink.emit();
        }
        source.close();
        sink.close();

Their implementation principle and time spent are the same.

[swankjesse]

Unclear what action to take here.