java - 在 Java 中创建大型 csv 文件变得非常慢

标签 java performance csv

我在尝试从另一个 csv 文件开始创建 csv 文件时遇到性能问题。 这是原始文件的样子:

country,state,co,olt,olu,splitter,ont,cpe,cpe.latitude,cpe.longitude,cpe.customer_class,cpe.phone,cpe.ip,cpe.subscriber_id
COUNTRY-0001,STATE-0001,CO-0001,OLT-0001,OLU0001,SPLITTER-0001,ONT-0001,CPE-0001,28.21487,77.451775,ALL,SIP:+674100002743@IMS.COMCAST.NET,SIP:E28EDADA06B2@IMS.COMCAST.NET,CPE_SUBSCRIBER_ID-QHLHW4
COUNTRY-0001,STATE-0002,CO-0002,OLT-0002,OLU0002,SPLITTER-0002,ONT-0002,CPE-0002,28.294018,77.068924,ALL,SIP:+796107443092@IMS.COMCAST.NET,SIP:58DD999D6466@IMS.COMCAST.NET,CPE_SUBSCRIBER_ID-AH8NJQ

可能有数百万行这样的行，我已经检测到 1.280.000 行的问题。

这是算法:

File csvInputFile = new File(csv_path);
int blockSize = 409600;
brCsvInputFile = new BufferedReader(frCsvInputFile, blockSize);

String line = null;
StringBuilder sbIntermediate = new StringBuilder();
skipFirstLine(brCsvInputFile);
while ((line = brCsvInputFile.readLine()) != null) {
    createIntermediateStringBuffer(sbIntermediate, line.split(REGEX_COMMA));
}


private static void skipFirstLine(BufferedReader br) throws IOException {
    String line = br.readLine();
    String[] splitLine = line.split(REGEX_COMMA);
    LOGGER.debug("First line detected! ");
    createIndex(splitLine);
    createIntermediateIndex(splitLine);
}

private static void createIndex(String[] splitLine) {
    LOGGER.debug("START method createIndex.");
    for (int i = 0; i < splitLine.length; i++)
        headerIndex.put(splitLine[i], i);
    printMap(headerIndex);
    LOGGER.debug("COMPLETED method createIndex.");
}

    private static void createIntermediateIndex(String[] splitLine) {

    LOGGER.debug("START method createIntermediateIndex.");
    com.tekcomms.c2d.xml.model.v2.Metadata_element[] metadata_element = null;
    String[] servicePath = newTopology.getElement().getEntity().getService_path().getLevel();

    if (newTopology.getElement().getMetadata() != null)
        metadata_element = newTopology.getElement().getMetadata().getMetadata_element();

    LOGGER.debug(servicePath.toString());
    LOGGER.debug(metadata_element.toString());

    headerIntermediateIndex.clear();
    int indexIntermediateId = 0;
    for (int i = 0; i < servicePath.length; i++) {
        String level = servicePath[i];
        LOGGER.debug("level is: " + level);
        headerIntermediateIndex.put(level, indexIntermediateId);
        indexIntermediateId++;
        // its identificator is going to be located to the next one
        headerIntermediateIndex.put(level + "ID", indexIntermediateId);
        indexIntermediateId++;
    }
    // adding cpe.latitude,cpe.longitude,cpe.customer_class, it could be
    // better if it would be metadata as well.
    String labelLatitude = newTopology.getElement().getEntity().getLatitude();
    // indexIntermediateId++;
    headerIntermediateIndex.put(labelLatitude, indexIntermediateId);
    String labelLongitude = newTopology.getElement().getEntity().getLongitude();
    indexIntermediateId++;
    headerIntermediateIndex.put(labelLongitude, indexIntermediateId);
    String labelCustomerClass = newTopology.getElement().getCustomer_class();
    indexIntermediateId++;
    headerIntermediateIndex.put(labelCustomerClass, indexIntermediateId);

    // adding metadata
    // cpe.phone,cpe.ip,cpe.subscriber_id,cpe.vendor,cpe.model,cpe.customer_status,cpe.contact_telephone,cpe.address,
    // cpe.city,cpe.state,cpe.zip,cpe.bootfile,cpe.software_version,cpe.hardware_version
    // now i need to iterate over each Metadata_element belonging to
    // topology.element.metadata
    // are there any metadata?
    if (metadata_element != null && metadata_element.length != 0)
        for (int j = 0; j < metadata_element.length; j++) {
            String label = metadata_element[j].getLabel();
            label = label.toLowerCase();
            LOGGER.debug(" ==label: " + label + " index_pos: " + j);
            indexIntermediateId++;
            headerIntermediateIndex.put(label, indexIntermediateId);
        }

    printMap(headerIntermediateIndex);
    LOGGER.debug("COMPLETED method createIntermediateIndex.");
}

读取整个数据集，1.280.000 行需要 800 毫秒!所以问题出在这个方法上

    private static void createIntermediateStringBuffer(StringBuilder sbIntermediate, String[] splitLine) throws ClassCastException,
        NullPointerException {

    LOGGER.debug("START method createIntermediateStringBuffer.");
    long start, end;
    start = System.currentTimeMillis();
    ArrayList<String> hashes = new ArrayList<String>();
    com.tekcomms.c2d.xml.model.v2.Metadata_element[] metadata_element = null;

    String[] servicePath = newTopology.getElement().getEntity().getService_path().getLevel();
    LOGGER.debug(servicePath.toString());

    if (newTopology.getElement().getMetadata() != null) {
        metadata_element = newTopology.getElement().getMetadata().getMetadata_element();
        LOGGER.debug(metadata_element.toString());
    }

    for (int i = 0; i < servicePath.length; i++) {
        String level = servicePath[i];
        LOGGER.debug("level is: " + level);
        if (splitLine.length > getPositionFromIndex(level)) {
            String name = splitLine[getPositionFromIndex(level)];
            sbIntermediate.append(name);
            hashes.add(name);
            sbIntermediate.append(REGEX_COMMA).append(HashUtils.calculateHash(hashes)).append(REGEX_COMMA);
            LOGGER.debug(" ==sbIntermediate: " + sbIntermediate.toString());
        }
    }

    //      end=System.currentTimeMillis();
    //      LOGGER.info("COMPLETED adding name hash. " + (end - start) + " ms. " + (end - start) / 1000 + " seg.");
    // adding cpe.latitude,cpe.longitude,cpe.customer_class, it should be
    // better if it would be metadata as well.
    String labelLatitude = newTopology.getElement().getEntity().getLatitude();
    if (splitLine.length > getPositionFromIndex(labelLatitude)) {
        String lat = splitLine[getPositionFromIndex(labelLatitude)];
        sbIntermediate.append(lat).append(REGEX_COMMA);
    }

    String labelLongitude = newTopology.getElement().getEntity().getLongitude();
    if (splitLine.length > getPositionFromIndex(labelLongitude)) {
        String lon = splitLine[getPositionFromIndex(labelLongitude)];
        sbIntermediate.append(lon).append(REGEX_COMMA);
    }
    String labelCustomerClass = newTopology.getElement().getCustomer_class();
    if (splitLine.length > getPositionFromIndex(labelCustomerClass)) {
        String customerClass = splitLine[getPositionFromIndex(labelCustomerClass)];
        sbIntermediate.append(customerClass).append(REGEX_COMMA);
    }
    //      end=System.currentTimeMillis();
    //      LOGGER.info("COMPLETED adding lat,lon,customer. " + (end - start) + " ms. " + (end - start) / 1000 + " seg.");
    // watch out metadata are optional, it can appear as a void chain!
    if (metadata_element != null && metadata_element.length != 0)
        for (int j = 0; j < metadata_element.length; j++) {
            String label = metadata_element[j].getLabel();
            LOGGER.debug(" ==label: " + label + " index_pos: " + j);
            if (splitLine.length > getPositionFromIndex(label)) {
                String actualValue = splitLine[getPositionFromIndex(label)];
                if (!"".equals(actualValue))
                    sbIntermediate.append(actualValue).append(REGEX_COMMA);
                else
                    sbIntermediate.append("").append(REGEX_COMMA);
            } else
                sbIntermediate.append("").append(REGEX_COMMA);
            LOGGER.debug(" ==sbIntermediate: " + sbIntermediate.toString());
        }//for
    sbIntermediate.append("\n");
    end = System.currentTimeMillis();
    LOGGER.info("COMPLETED method createIntermediateStringBuffer. " + (end - start) + " ms. ");
}

如您所见，此方法将预先计算的行添加到 StringBuffer，从输入 csv 文件读取每一行，从这些行计算新数据，最后将生成的行添加到 StringBuffer，所以最后我可以使用以下命令创建文件该缓冲区。

我已经运行了jconsole，我可以看到没有内存泄漏，我可以看到代表对象创建的锯齿和GC重新收集garbaje。它永远不会超越内存堆阈值。

我注意到的一件事是，向 StringBuffer 添加新行所需的时间是在很少的毫秒范围内完成的(5,6,10)，但随着时间的推移而增加，达到(100-200)女士和我怀疑在不久的将来会有更多，所以这可能是战马。

我尝试分析代码，我知道有3个for循环，但它们很短，第一个循环仅迭代8个元素:

for (int i = 0; i < servicePath.length; i++) {
        String level = servicePath[i];
        LOGGER.debug("level is: " + level);
        if (splitLine.length > getPositionFromIndex(level)) {
            String name = splitLine[getPositionFromIndex(level)];
            sbIntermediate.append(name);
            hashes.add(name);
            sbIntermediate.append(REGEX_COMMA).append(HashUtils.calculateHash(hashes)).append(REGEX_COMMA);
            LOGGER.debug(" ==sbIntermediate: " + sbIntermediate.toString());
        }
    }

我测量了从分割线获取名称所需的时间，它毫无值(value)，0毫秒，与calculateHash方法相同，0毫秒。

另一个循环实际上是相同的，迭代 0 到 n，其中 n 是一个非常小的整数，例如 3 到 10，所以我不明白为什么需要更多时间来完成该方法，唯一的事情我发现向缓冲区添加新行的过程变得很慢。

我正在考虑一种生产者消费者多线程策略，一个读取器线程读取每一行并将它们放入循环缓冲区中，另一个线程逐个读取它，处理它们并将预先计算的行添加到 StringBuffer 中，这是线程安全，当文件被完全读取时，读取线程向另一个线程发送一条消息，告诉它们停止。最后我必须将此缓冲区保存到文件中。你怎么认为？这是一个好主意？

最佳答案

I am thinking about a producer consumer multi threaded strategy, a reader thread that reads every line and put them into a circular buffer, another threads take it one by one, process them and add a precalculated line to the StringBuffer, which is thread safe, when the file is fully readed, the reader thread sends a message to to the another threads telling them to stop. Finally i have to save this buffer to a file. What do you think? this is a good idea?

也许吧，但是工作量很大，我会先尝试一些更简单的方法。

line.split(REGEX_COMMA)

您的REGEX_COMMA是一个被编译成正则表达式一百万次的字符串。这很简单，但我会尝试使用 Pattern相反。

你的 split 产生了很多垃圾。也许您应该通过手动将输入拆分为重复使用的 ArrayList<String> 来避免这种情况。 (只有几行)。

如果您需要的只是将结果写入文件，那么最好避免构建一个巨大的字符串。也许是List<String>甚至是List<StringBuilder>会更好，也许直接写入缓冲流可以。

您似乎只使用 ASCII。您的编码取决于平台，这可能意味着您使用的是 UTF-8，这可能很慢。切换到更简单的编码可能会有所帮助。

与 byte[] 合作而不是String很可能会有所帮助。字节大小是字符的一半，读取文件时无需转换。您所做的所有操作都可以同样轻松地使用字节完成。

One thing i have noticed is that the time needed for add a new line to the StringBuffer is completed within a very few ms range, (5,6,10), but is raising with time, to (100-200) ms and i suspect more in a near future, so probably this is the battle horse.

这就是调整大小，可以通过使用建议的 ArrayList<String> 来加快速度。 ，因为要复制的数据量要少得多。当缓冲区变大时写出数据也可以。

I have meassured the time needed to get the name from the splitline and it is worthless, 0 ms, the same to calculateHash method, 0 ms.

切勿使用currentTimeMillis为此 nanoTime严格来说更好。使用分析器。分析器的问题在于它改变了它应该测量的内容。作为穷人的分析器，您可以计算可疑方法内部花费的所有时间的总和，并将其与总时间进行比较。

运行程序时CPU负载是多少以及GC做了什么？

关于java - 在 Java 中创建大型 csv 文件变得非常慢，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/27295356/

上一篇：java - 数组意外增加两次？

下一篇：java - Junit 为整个集成测试(所有测试类)设置一次

相关文章：

Node.js 中的 Json 到 csv

sql - 是否可以在 PLSQL/Oracle 中动态创建外部表

java - android布局，有面板吗？

java - if 语句中的动态 AND 条件

java - 检查 JSON 节点是否为 null

c++ - std::sort 指针容器

MySQL - 优化查询以使用临时删除和使用文件排序

java - 在哪里可以下载 Java Mission Control(7)(OpenJDK11 或更高版本)？

c++ - 重载数组下标 [] 运算符慢

python - 如何在读取文本文件时删除多个空格

©2024 IT工具网  联系我们