从多个点扫描文件

Question

我有一个文件abc.txt，其中包含打印两次的字母，用换行符分隔

abcdefghijklmopqrstuvwxyz
abcdefghijklmopqrstuvwxyz

我想创建一个可以同时解析行的解析器。例如，每行一个 goroutine。我目前尝试这样做的过程是：

• 创建一个通道来接收文本行
• 为每一行创建一个新的扫描仪
• 将该扫描仪和通道传递给 goroutine
• 主进程中的进程结果

但是，只有一个扫描器返回有用的输出。我正在尝试做的代码是这样的：

func main() {
    file, err := os.Open("./strangeness/abc.txt")
    if err != nil {
        log.Panic(err)
    }
    defer file.Close()

    inChan := make(chan string)

    for i := 0; i < 2; i++ {
        var scanner scanner.Scanner
        file.Seek(27, 0)

        scanner.Init(file)

        go parseLine(fmt.Sprintf("Scanner %v:", i), &scanner, inChan)
    }

    for msg := range inChan {
        fmt.Println(msg)
    }
}

func parseLine(name string, scanner *scanner.Scanner, out chan string) {
    for i := 0; i < 26; i++ {
        out <- fmt.Sprintf("%s %c", name, scanner.Next())
    }
}

我想我可能对 go text/scanner 的工作方式或文件的一般工作方式有一些误解，但我无法追踪错误的实际来源。

Answer 1

问题似乎是因为文件的 2 个扫描仪同时移动头部。

可以通过创建 2 个文件句柄来实现所需的结果，每个句柄都有自己的扫描仪。以下对我有用

package main

import (
    "fmt"
    "log"
    "os"
    "text/scanner"
    "time"
)

func main(){
    var file [2]*os.File
    var err error
    file[0], err = os.Open("./abc.txt")
    file[1], err = os.Open("./abc.txt")
    if err != nil {
        log.Panic(err)
    }
    defer file[0].Close()
    defer file[1].Close()
    var scanner [2]scanner.Scanner
    inChan := make(chan string)


    for i := 0; i < 2; i++ {
        var n int64 = (int64)(i) * 26
        file[i].Seek(n, 0)

        scanner[i].Init(file[i])
        fmt.Println(scanner[0].Pos)
        go parseLine(fmt.Sprintf("Scanner %v:", i), &scanner[i], inChan)
    }

    for msg := range inChan {
        fmt.Println(msg)
    }
}

func parseLine(name string, scanner *scanner.Scanner, out chan string) {
    for i := 0; i < 26; i++ {
        out <- fmt.Sprintf("%s %c", name, scanner.Next())
    }
    time.Sleep(time.Second * 10)
    close(out)
}

Answer 2

文件具有的属性之一是单个读取位置，而不是每个扫描仪、每个线程或每个 goroutine 一个。当您在多个扫描仪对象（或其他任何对象）之间共享单个 os.File 时，从文件中读取的第一个将推进每个其他扫描仪的读取指针。在您的示例中，运行的第一个 goroutine 将从文件中读取该行，第二个尝试读取但已经在文件末尾。

要完成这项工作，您只需要读取文件一件事，并且您需要确保发送给 goroutine 的数据不被共享（您不会重复读取单个缓冲区并发送相同的数据）到处缓冲，下一次读取将覆盖它）。

现在是考虑并发性的好时机，如果这真的值得付出努力。 到目前为止，这个程序最慢的部分实际上是从磁盘读取文件，而且没有多少goroutines 将使这更快。在最佳的单线程程序中，额外的缓冲区副本不是必需的，并且 goroutine 同步也有成本。我的直觉是，在这里使用 goroutine 会使程序更加复杂并且可能更慢。

我对您的程序所做的核心更改是只有一个可以读取文件的东西；例如，程序中的主循环。 bufio 包包含一个 Scanner 对象，它可以一次读取文件一行，并生成复制的字符串。我会启动一个工作 goroutine 池一次，然后给它们喂线：

lines := make(chan string)
file, err := os.Open("./strangeness/abc.txt")
if err != nil { ... }

scan := bufio.NewScanner(file)
for scan.Scan() {
    lines <- scan.Text()
}
close(lines)

https://play.golang.org/p/o7UwZrgfVy7 有一个更完整的编译示例。请注意，goroutine 结构需要一些推理：我已经启动了一个单独的 goroutine 来处理结果，并有一个单独的通道来表示它的完成。