Я работаю над некоторымиSocketChannel-До-SocketChannel код, который лучше всего работает с прямым байтовым буфером - долгоживущий и большой (от десятков до сотен мегабайт на соединение). При этом хеширование точной структуры цикла выполняетсяFileChannels, я запустил несколько микро-тестов наByteBuffer.allocate() противByteBuffer.allocateDirect() спектакль.

В результатах был сюрприз, который я не могу объяснить. На приведенном ниже графике очень четко выражен обрыв в 256 КБ и 512 КБ дляByteBuffer.allocate() передача реализации - производительность падает на ~ 50%! Там также, кажется, должен быть меньший утес производительности дляByteBuffer.allocateDirect(), (Ряд% -gain помогает визуализировать эти изменения.)

Размер буфера (в байтах) в зависимости от времени (MS)

Почему нечетная разница в производительности междуByteBuffer.allocate() а такжеByteBuffer.allocateDirect()? Что именно происходит за занавесом?

Это очень хорошо, может быть, зависит от оборудования и ОС, так что вот эти детали:

MacBook Pro с двухъядерным процессором Core 2SSD-накопитель Intel X25MOSX 10.6.4

Исходный код по запросу:

package ch.dietpizza.bench;

import static java.lang.String.format;
import static java.lang.System.out;
import static java.nio.ByteBuffer.*;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.UnknownHostException;
import java.nio.ByteBuffer;
import java.nio.channels.Channels;
import java.nio.channels.ReadableByteChannel;
import java.nio.channels.WritableByteChannel;

public class SocketChannelByteBufferExample {
    private static WritableByteChannel target;
    private static ReadableByteChannel source;
    private static ByteBuffer          buffer;

    public static void main(String[] args) throws IOException, InterruptedException {
        long timeDirect;
        long normal;
        out.println("start");

        for (int i = 512; i <= 1024 * 1024 * 64; i *= 2) {
            buffer = allocateDirect(i);
            timeDirect = copyShortest();

            buffer = allocate(i);
            normal = copyShortest();

            out.println(format("%d, %d, %d", i, normal, timeDirect));
        }

        out.println("stop");
    }

    private static long copyShortest() throws IOException, InterruptedException {
        int result = 0;
        for (int i = 0; i < 100; i++) {
            int single = copyOnce();
            result = (i == 0) ? single : Math.min(result, single);
        }
        return result;
    }


    private static int copyOnce() throws IOException, InterruptedException {
        initialize();

        long start = System.currentTimeMillis();

        while (source.read(buffer)!= -1) {    
            buffer.flip();  
            target.write(buffer);
            buffer.clear();  //pos = 0, limit = capacity
        }

        long time = System.currentTimeMillis() - start;

        rest();

        return (int)time;
    }   


    private static void initialize() throws UnknownHostException, IOException {
        InputStream  is = new FileInputStream(new File("/Users/stu/temp/robyn.in"));//315 MB file
        OutputStream os = new FileOutputStream(new File("/dev/null"));

        target = Channels.newChannel(os);
        source = Channels.newChannel(is);
    }

    private static void rest() throws InterruptedException {
        System.gc();
        Thread.sleep(200);      
    }
}