Java FileChannel против BufferedReader — Spring Batch — Reader

Вы вызываете много накладных расходов с постоянными проверками hasRemaining()/read(), а также с постоянными вызовами get(). Вероятно, было бы лучше get() весь буфер превратить в массив и обработать его напрямую, вызывая read() только тогда, когда вы дойдете до конца.

И чтобы ответить на вопрос в комментариях, вы не должны выделять новый ByteBuffer за чтение. Это дорого. Продолжайте использовать тот же. И обратите внимание, не используйте DirectByteBuffer для этого приложения. Это не подходит: это подходит только тогда, когда вы хотите, чтобы данные оставались к югу от границы JVM/JNI, например. при простом копировании между каналами.

Но я думаю, что я бы выбросил это или, скорее, переписал бы его, используя BufferedReader.read(), а не readLine(), за которым следует разбиение строки, и используя почти ту же логику, что и здесь, за исключением того, что вам не нужно продолжать вызывать hasRemaining() и заполнение буфера, что BufferedReader сделает за вас автоматически.

Вы должны позаботиться о том, чтобы сохранить результат read() в int и проверять его на -1 после каждого read().

Мне не ясно, что вы вообще должны использовать Reader, если только вы не знаете, что у вас многобайтовый текст. Возможно, простое BufferedInputStream было бы более подходящим.

Хотя нельзя с уверенностью сказать, как будет вести себя конкретный код, я полагаю, что лучший способ - профилировать его так же, как и вы. FileChannel, хотя и считается более быстрым, на самом деле не помогает в вашем случае. Но это может быть не из-за чтения из файла, а фактическая обработка, которую вы выполняете с контентом, который вы читаете. При работе с файлами я хотел бы отметить одну статью: https://www.redgreencode.com/why-is-java-io-slow/

Также соответствующая кодовая база Github тест Java IO

Я хотел бы указать, что этот код использует комбинацию обоих миров fos = new FileOutputStream(outputFile); outFileChannel = fos.getChannel(); bufferedWriter = new BufferedWriter(Channels.newWriter(outFileChannel, "UTF-8"));

Поскольку это читается в вашем случае, я рассмотрю

File inputFile = new File("C:\\input.txt");
FileInputStream fis = new FileInputStream(inputFile);
FileChannel inputChannel = fis.getChannel();
BufferedReader bufferedReader = new BufferedReader(Channels.newReader(inputChannel,"UTF-8"));

Также я буду настраивать размер фрагмента, а с пакетом Spring всегда будет метод проб и ошибок, чтобы найти золотую середину.

В совершенно не связанной с этим заметке причина вашей проблемы с невозможностью использования BufferedReader связана с удвоением символов, и я предполагаю, что это чаще происходит с символами ebcdic. источник.

import java.io.UnsupportedEncodingException;

public class EbcdicConvertor {

    public static void main(String[] args) throws UnsupportedEncodingException {
        int index = 0;
        for (int i = -127; i < 128; i++) {
            byte[] b = new byte[1];
            b[0] = (byte) i;
            String cp037 = new String(b, "CP037");
            if (cp037.getBytes().length == 2) {
                index++;
                System.out.println(i + "::" + cp037);
            }
        }
        System.out.println(index);
    }
}

Приведенный выше ответ не проверяет мою фактическую гипотезу. Вот реальная программа для измерения времени. Результаты говорят сами за себя в файле размером 200 МБ.

import java.io.File;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.Channels;
import java.nio.channels.FileChannel;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.regex.Pattern;

public class ReadComplexDelimitedFile {
    private static long total = 0;
    private static final Pattern DELIMITER_PATTERN = Pattern.compile("\\^\\|\\^");

    private void readFileUsingScanner() {

        String s;
        try (Scanner stdin = new Scanner(new File(this.getClass().getResource("input.txt").getPath()))) {
            while (stdin.hasNextLine()) {
                s = stdin.nextLine();
                String[] fields = DELIMITER_PATTERN.split(s, 0);
                total = total + fields.length;
            }
        } catch (Exception e) {
            System.err.println("Error");
        }

    }

    private void readFileUsingCustomBufferedReader() {

        try (BufferedReader stdin = new BufferedReader(new FileReader(new File(this.getClass().getResource("input.txt").getPath())))) {
            String s;
            while ((s = stdin.readLine()) != null) {
                String[] fields = DELIMITER_PATTERN.split(s, 0);
                total += fields.length;
            }
        } catch (Exception e) {
            System.err.println("Error");
        }

    }

    private void readFileUsingBufferedReader() {

        try (java.io.BufferedReader stdin = new java.io.BufferedReader(new FileReader(new File(this.getClass().getResource("input.txt").getPath())))) {
            String s;
            while ((s = stdin.readLine()) != null) {
                String[] fields = DELIMITER_PATTERN.split(s, 0);
                total += fields.length;
            }
        } catch (Exception e) {
            System.err.println("Error");
        }

    }


    private void readFileUsingBufferedReaderFileChannel() {
        try (FileInputStream fis = new FileInputStream(this.getClass().getResource("input.txt").getPath())) {
            try (FileChannel inputChannel = fis.getChannel()) {
                try (BufferedReader stdin = new BufferedReader(Channels.newReader(inputChannel, "UTF-8"))) {
                    String s;
                    while ((s = stdin.readLine()) != null) {
                        String[] fields = DELIMITER_PATTERN.split(s, 0);
                        total = total + fields.length;
                    }
                }
            } catch (Exception e) {
                System.err.println("Error");
            }
        } catch (Exception e) {
            System.err.println("Error");
        }

    }

    private void readFileUsingBufferedReaderByteFileChannel() {
        try (FileInputStream fis = new FileInputStream(this.getClass().getResource("input.txt").getPath())) {
            try (FileChannel inputChannel = fis.getChannel()) {
                try (BufferedReader stdin = new BufferedReader(Channels.newReader(inputChannel, "UTF-8"))) {
                    int b;
                    StringBuilder sb = new StringBuilder();
                    while ((b = stdin.read()) != -1) {
                        if (b == 10) {

                            total = total + DELIMITER_PATTERN.split(sb, 0).length;
                            sb = new StringBuilder();
                        } else {
                            sb.append((char) b);
                        }
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        } catch (Exception e) {
            System.err.println("Error");
        }

    }

    private void readFileUsingFileChannelStream() {

        try (RandomAccessFile fis = new RandomAccessFile(new File(this.getClass().getResource("input.txt").getPath()), "r")) {
            try (FileChannel inputChannel = fis.getChannel()) {
                ByteBuffer byteBuffer = ByteBuffer.allocate(8192);
                ByteBuffer recordBuffer = ByteBuffer.allocate(250);
                int recordLength = 0;
                while ((inputChannel.read(byteBuffer)) != -1) {
                    byte b;
                    byteBuffer.flip();
                    while (byteBuffer.hasRemaining() && (b = byteBuffer.get()) != -1) {
                        if (b == 10) {
                            recordBuffer.flip();
                            total = total + splitIntoFields(recordBuffer, recordLength);
                            recordBuffer.clear();
                            recordLength = 0;
                        } else {
                            ++recordLength;
                            recordBuffer.put(b);
                        }
                    }
                    byteBuffer.clear();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    private int splitIntoFields(ByteBuffer recordBuffer, int recordLength) {
        byte b;
        String[] fields = new String[17];
        int fieldCount = -1;
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < recordLength - 1; i++) {
            b = recordBuffer.get(i);
            if (b == 94 && recordBuffer.get(++i) == 124 && recordBuffer.get(++i) == 94) {
                fields[++fieldCount] = sb.toString();
                sb = new StringBuilder();
            } else {
                sb.append((char) b);
            }
        }
        fields[++fieldCount] = sb.toString();
        return fields.length;

    }


    public static void main(String args[]) {
        //JVM wamrup
        for (int i = 0; i < 100000; i++) {
            total += i;
        }
        // We know scanner is slow-Still warming up
        ReadComplexDelimitedFile readComplexDelimitedFile = new ReadComplexDelimitedFile();
        List<Long> longList = new ArrayList<>(50);
        for (int i = 0; i < 50; i++) {
            total = 0;
            long startTime = System.nanoTime();
            readComplexDelimitedFile.readFileUsingScanner();
            long stopTime = System.nanoTime();
            long timeDifference = stopTime - startTime;
            longList.add(timeDifference);

        }
        System.out.println("Time taken for readFileUsingScanner");
        longList.forEach(System.out::println);
        // Actual performance test starts here

        longList = new ArrayList<>(10);
        for (int i = 0; i < 10; i++) {
            total = 0;
            long startTime = System.nanoTime();
            readComplexDelimitedFile.readFileUsingBufferedReaderFileChannel();
            long stopTime = System.nanoTime();
            long timeDifference = stopTime - startTime;
            longList.add(timeDifference);

        }
        System.out.println("Time taken for readFileUsingBufferedReaderFileChannel");
        longList.forEach(System.out::println);
        longList.clear();
        for (int i = 0; i < 10; i++) {
            total = 0;
            long startTime = System.nanoTime();
            readComplexDelimitedFile.readFileUsingBufferedReader();
            long stopTime = System.nanoTime();
            long timeDifference = stopTime - startTime;
            longList.add(timeDifference);

        }
        System.out.println("Time taken for readFileUsingBufferedReader");
        longList.forEach(System.out::println);
        longList.clear();
        for (int i = 0; i < 10; i++) {
            total = 0;
            long startTime = System.nanoTime();
            readComplexDelimitedFile.readFileUsingCustomBufferedReader();
            long stopTime = System.nanoTime();
            long timeDifference = stopTime - startTime;
            longList.add(timeDifference);

        }
        System.out.println("Time taken for readFileUsingCustomBufferedReader");
        longList.forEach(System.out::println);
        longList.clear();
        for (int i = 0; i < 10; i++) {
            total = 0;
            long startTime = System.nanoTime();
            readComplexDelimitedFile.readFileUsingBufferedReaderByteFileChannel();
            long stopTime = System.nanoTime();
            long timeDifference = stopTime - startTime;
            longList.add(timeDifference);

        }
        System.out.println("Time taken for readFileUsingBufferedReaderByteFileChannel");
        longList.forEach(System.out::println);
        longList.clear();
        for (int i = 0; i < 10; i++) {
            total = 0;
            long startTime = System.nanoTime();
            readComplexDelimitedFile.readFileUsingFileChannelStream();
            long stopTime = System.nanoTime();
            long timeDifference = stopTime - startTime;
            longList.add(timeDifference);

        }
        System.out.println("Time taken for readFileUsingFileChannelStream");
        longList.forEach(System.out::println);

    }
}

BufferedReader был написан очень давно, и поэтому мы можем переписать некоторые части, относящиеся к этому примеру. Например, нам не нужны \r и skipLF или skipCR или подобные вещи. Мы собираемся прочитать файл (нет необходимости в синхронизации) По расширению нет необходимости в StringBuffer, даже если в противном случае можно использовать StringBuilder. Сразу видно улучшение производительности.

опасный взлом, удалите синхронизированный и замените StringBuffer на StringBuilder, не используйте его без надлежащего тестирования и не зная, что вы делаете

public String readLine() throws IOException {
        StringBuilder s = null;
        int startChar;


        bufferLoop:
        for (; ; ) {

            if (nextChar >= nChars)
                fill();
            if (nextChar >= nChars) { /* EOF */
                if (s != null && s.length() > 0)
                    return s.toString();
                else
                    return null;
            }
            boolean eol = false;
            char c = 0;
            int i;

            /* Skip a leftover '\n', if necessary */


            charLoop:
            for (i = nextChar; i < nChars; i++) {
                c = cb[i];
                if (c == '\n') {
                    eol = true;
                    break charLoop;
                }
            }

            startChar = nextChar;
            nextChar = i;

            if (eol) {
                String str;
                if (s == null) {
                    str = new String(cb, startChar, i - startChar);
                } else {
                    s.append(cb, startChar, i - startChar);
                    str = s.toString();
                }
                nextChar++;
                return str;
            }

            if (s == null)
                s = new StringBuilder(defaultExpectedLineLength);
            s.append(cb, startChar, i - startChar);
        }
    }

Java 8 Intel i5 12 ГБ ОЗУ Windows 10 Результат:

Время, затраченное на readFileUsingBufferedReaderFileChannel::

• 2581635057 1849820885 1763992972 1770510738 1746444157 1733491399 1740530125 1723907177 1724280512 1732445638

Время, затраченное на readFileUsingBufferedReader

• 1851027073 1775304769 1803507033 1789979554 1786974538 1802675458 1789672780 1798036307 1789847714 1785302003

Время, затраченное на readFileUsingCustomBufferedReader

1. 1745220476 1721039975 1715383650 1728548462 1724746005 1718177466 1738026017 1748077438 1724608192 1736294175

Время, затраченное на readFileUsingBufferedReaderByteFileChannel

• 2872857919 2480237636 2917488143 2913491126 2880117231 2904614745 2911756298 2878777496 2892169722 2888091211

Время, затраченное на readFileUsingFileChannelStream

• 3039447073 2896156498 2538389366 2906287280 2887612064 2929288046 2895626578 2955326255 2897535059 2884476915

Процесс завершен с кодом выхода 0

Я попробовал NIO со всеми возможными вариантами (предоставленными в этом посте и насколько я знаю и исследовал) и обнаружил, что он нигде не приближается к BufferedReader с точки зрения чтения текстового файла.

Изменив BufferedReader на использование StringBuilder вместо StringBuffer, я не вижу значительного улучшения производительности (всего несколько секунд для некоторых файлов, а некоторые из них лучше использовать сам StringBuffer).

Удаление синхронизированного блока также не дало особых улучшений. И не стоит настраивать то, чем мы не получили никакой пользы.

Ниже показано время (чтение, обработка, запись — время, затраченное на обработку и запись, незначительно — даже не 20% времени) для файла размером около 50 ГБ. NIO: 71,67 (минуты) IO (BufferedReader): 10,84 ( минут)

Спасибо всем за ваше время, чтобы прочитать и ответить на этот пост и дать предложения.

Основная проблема здесь заключается в очень быстром создании нового byte[] (fieldBytes = new byte[maxFieldSize];).

Поскольку для каждой итерации создается новый массив, сборка мусора запускается очень часто, что вызывает «остановить мир» для освобождения памяти.

Кроме того, создание объекта может быть дорогостоящим.

Мы могли бы сначала инициализировать массив байтов, а затем отслеживать индексы, чтобы просто преобразовать поле в строку с конечным индексом.

В любом случае, BufferedReader работает быстрее, чем FileChannel, по крайней мере, для чтения файлов ASCII, и для простоты кода мы продолжали использовать сам Bufferred Reader.

Используя Bufferred reader, усилия по разработке и тестированию могут быть уменьшены за счет отсутствия утомительной логики для поиска разделителей и заполнения объекта.