java - Go 和 Java 之间的 IO 性能

Question

我在我的 Mac(Majave 版本)上用 4Cpus/i5 和 16G 内存做了一个 go(1.11) 和 java(1.8) 的简单性能测试，我发现，读取一个小文件，golang 快了 6~7 倍比 java 。下面是我的测试代码，我想确认一下是我的测试代码错了还是漏了什么？

1. Java

使用concurrent.ExecutorService

import java.io.*;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;



class TaskWithResult implements Callable<String> {
        private static String readToString() {
        String fileName = "/Users/pis/IdeaProjects/Test/src/data/test.txt";
        File file = new File(fileName);
        Long filelength = file.length();
        byte[] filecontent = new byte[filelength.intValue()];
        try {
            FileInputStream in = new FileInputStream(file);
            in.read(filecontent);
            in.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        SimpleDateFormat myFmt=new SimpleDateFormat("yyyy-MM-dd HH: mm: ss: SSS: ");
        Date d1 = new Date();
        return myFmt.format(d1);
    }

    /**
     * 任务的具体过程，一旦任务传给ExecutorService的submit方法，
     * 则该方法自动在一个线程上执行
     */
    public String call() throws Exception {
        String result = readToString();
        System.out.println(result);
        //该返回结果将被Future的get方法得到
        return result;
    }
}


public class readFile{
    public static void main(String args[]){
        ExecutorService es = Executors.newFixedThreadPool(5);
        List<Future<String>> resultList = new ArrayList<Future<String>>();
        SimpleDateFormat myFmt=new SimpleDateFormat("yyyy-MM-dd HH: mm: ss: SSS");
        Date d1 = new Date();
        System.out.println("Start Time:"+myFmt.format(d1));
        for (int i = 0; i < 1000; i++){
            //使用ExecutorService执行Callable类型的任务，并将结果保存在future变量中
            Future<String> future = es.submit(new TaskWithResult());
            //将任务执行结果存储到List中
            resultList.add(future);
        }
    }

}

1. 去

通过 channel

package main

import (
    "fmt"
    "io/ioutil"
    "time"
)

func readFile(fileName string, p chan string)chan string {
    f, err := ioutil.ReadFile(fileName)
    if err!=nil{
        fmt.Println("read file error")
    }
    p<-string(f)
    return p
}

func main() {
    le := 1000
    p := make(chan string, le)
    start := time.Now()
    for i:=0;i<le;i++{
        go readFile("test.txt", p)
    }
    fmt.Println(fmt.Sprintf("Start Time: %s", start))
    for i:=0;i<le;i++{
        <-p
        fmt.Println(fmt.Sprintf("End Time: %s, duration: %f", time.Now(), time.Since(start).Seconds()))
    }

}

• 结果

  • Go:在大约 0.0197 秒内完成所有任务

    开始时间:2018-12-24 15:30:50.333694 +0800 CST m=+0.000325519

    ...

    结束时间

    ...

    结束时间:2018-12-24 15:30:50.353409 +0800 CST m=+0.020040254，时长:0.019715

  • Java:在大约 122 毫秒内完成所有任务

    开始时间:2018-12-24 15:30:31:301

    ...

    2018-12-24 15:30:31:422

我的测试数据文件是一个非常简单的txt，有几行(大约362B)。我的测试代码在测试读取go和java之间的小文件时有问题吗？有人请帮帮我。提前致谢:)

Answer 1

我看到了一些问题，无论是从概念的角度还是技术的角度。

您使用一个 channel 来返回您的结果集(不错，有点)，但是您只是简单地丢弃了结果。此外，您使用的是无缓冲 channel ，因此您在那里有一个瓶颈。请注意，这本身并不是问题，因为管道是构建程序的一种好方法——恕我直言，您只是在这里以错误的方式使用了它。行内的东西

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    le := 1000

    // We want to wait until the operations finish
    var wg sync.WaitGroup

    // We "prealloc" err, since we do not want le * allocations
    var err error


    start := time.Now()
    for i := 0; i < le; i++ {

        // Add an operation to wait for to the group
        wg.Add(1)
        go func() {
            // Ensure the WaitGroup is notified we are done (bar a panic)
            defer wg.Done()

            // Short notation, since we are not interested in the result set
            if _,err = ioutil.ReadFile(fileName);err!=nil{
             fmt.Println("read file error")
            }

        }()

    }

    // Wait until all operations are finished.
    wg.Wait()
    fmt.Printf("%d iterations took %s", le, time.Since(start))
}

将是我的解决方案。如果我有想法做这样的事情。

但是如果我们深入查看代码，基本上这里唯一工作的组件是 ioutil.ReadFile。将其用于值得进行基准测试的程序部分首先是一个非常糟糕的想法™。它应该用于相当小的文件(例如配置文件)——它本身并不是您要进行基准测试的程序的一部分。

您做要进行基准测试的是您刚刚读取的文件的处理逻辑。让我给你举个例子:假设你想读入一堆小的 JSON 文件，解码它们，修改它们，再次编码它们并将它们发送到 REST API。那么，在这种情况下，您想对程序的哪一部分进行基准测试？我敢打赌处理文件的逻辑。因为那是您可以实际优化的程序部分。您既不能优化 ioutil.ReadFile 也不能优化服务器。除非你碰巧也写了这个。在这种情况下，您可能希望从服务器包内对服务器逻辑进行基准测试。

最后但同样重要的是，您的问题标题为“Go 和 Java 之间的 IO 性能”。要实际测量 IO 性能，您需要非常大的 IO 操作。我倾向于为此使用 ISO 图像 - 我倾向于使用真实世界的数据。