如何提高Go中逐行读取大文件的速度

逐行读取大文件时，Go 的速度可能会受到限制。在给定的示例中，读取 680MB 文件并检查每一行是否包含特定字符串的过程需要 3 秒多。提高速度的方法包括增加缓冲区大小，但瓶颈可能仍然存在于 I/O 读取中。

我试图找出逐行读取大文件并检查该行是否包含字符串的最快方法。我正在测试的文件大小约为 680mb：

    package main
    
    import (
        "bufio"
        "fmt"
        "os"
        "strings"
    )
    
    func main() {
        f, err := os.open("./crackstation-human-only.txt")
    
        scanner := bufio.newscanner(f)
        if err != nil {
            panic(err)
        }
        defer f.close()
    
        for scanner.scan() {
            if strings.contains(scanner.text(), "iforgotmypassword") {
                fmt.println(scanner.text())
            }
        }
    }

在我的机器上构建程序并计时后，它运行了 3 秒多 ./速度3.13s用户1.25s系统122%cpu 3.563总计

增加缓冲区后

buf := make([]byte, 64*1024)
scanner.Buffer(buf, bufio.MaxScanTokenSize)

情况好一点了 ./速度2.47s用户0.25s系统104%cpu 2.609总计

我知道它可以变得更好，因为其他工具可以在一秒钟内完成它，而无需任何类型的索引。这种方法的瓶颈是什么？

0.33s 用户 0.14s 系统 94% cpu 0.501 总计

解决方案

最后编辑

这是一个“逐行”解决方案，需要很短的时间，它会打印整个匹配行。

package main

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

func main() {
    dat, _ := ioutil.readfile("./jumble.txt")
    i := bytes.index(dat, []byte("iforgotmypassword"))
    if i != -1 {
        var x int
        var y int
        for x = i; x > 0; x-- {
            if dat[x] == byte('\n') {
                break
            }
        }
        for y = i; y < len(dat); y++ {
            if dat[y] == byte('\n') {
                break
            }
        }
        fmt.println(string(dat[x : y+1]))
    }
}

real    0m0.421s
user    0m0.068s
sys     0m0.352s

原始答案

如果您只需要查看字符串是否在文件中，为什么不使用正则表达式？

注意：我将数据保留为字节数组，而不是转换为字符串。

package main

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

var regex = regexp.mustcompile(`ilostmypassword`)

func main() {
    dat, _ := ioutil.readfile("./jumble.txt")
    if regex.match(dat) {
        fmt.println("yes")
    }
}

jumble.txt 是一个 859 mb 的混乱文本，其中包含换行符。

使用 time ./code 运行我得到：

real    0m0.405s
user    0m0.064s
sys     0m0.340s

为了尝试回答你的评论，我不认为瓶颈本质上来自于逐行搜索，golang 使用一种有效的算法来搜索字符串/符文。

我认为瓶颈来自于io读取，当程序从文件读取时，它通常不是排在读取队列中的第一个，因此，程序必须等到它可以读取才能开始实际比较。因此，当您一遍又一遍地读入时，您将被迫等待轮到 io。

给你一些数学知识，如果你的缓冲区大小是 64 * 1024（或 65535 字节），并且你的文件是 1 gb。除 1 gb / 65535 字节之外，检查整个文件需要 15249 次读取。在我的方法中，我“立即”读取整个文件并检查构造的数组。 罢工>

我能想到的另一件事是移动文件所需的循环总量以及每个循环所需的时间：

给出以下代码：

dat, _ := ioutil.readfile("./jumble.txt")
sdat := bytes.split(dat, []byte{'\n'})
for _, l := range sdat {
    if bytes.equal([]byte("iforgotmypassword"), l) {
        fmt.println("yes")
    }
}

我计算出每个循环平均需要 32 纳秒，字符串 iforgotmypassword 位于文件中的第 100000000 行，因此该循环的执行时间大约为 32 纳秒 * 100000000 ~= 3.2 秒。

使用我自己的 700mb 测试文件和您的原始文件，时间仅超过 7 秒

使用 grep 是 0.49 秒

使用这个程序（它不会打印出该行，它只是说是） 0.082秒

package main

import (
    "bytes"
    "fmt"
    "io/ioutil"
    "os"
)

func check(e error) {
    if e != nil {
        panic(e)
    }
}
func main() {
    find := []byte(os.Args[1])
    dat, err := ioutil.ReadFile("crackstation-human-only.txt")
    check(err)
    if bytes.Contains(dat, find) {
        fmt.Print("yes")
    }
}

今天带大家了解了的相关知识，希望对你有所帮助；关于Golang的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~