多个go例程读取pcap文件不能提高性能？

目前golang学习网上已经有很多关于Golang的文章了，自己在初次阅读这些文章中，也见识到了很多学习思路；那么本文《多个go例程读取pcap文件不能提高性能？》，也希望能帮助到大家，如果阅读完后真的对你学习Golang有帮助，欢迎动动手指，评论留言并分享~

我需要读取大约600个pcap文件，每个文件大约100mb。 我使用gopacket加载pcap文件，并检查它。

case1：使用1个例程进行检查。

案例2：使用40个例程进行检查。

而且我发现case1和case2消耗的时间是差不多的。 不同的是case1的cpu使用率只有200%，而case2可以达到3000%。 我的问题是为什么多个例程无法提高性能？ 代码中有一些注释，希望对您有所帮助。

package main

import (
    "flag"
    "fmt"
    "io/ioutil"
    "log"
    "os"
    "strings"
    "sync"

    "github.com/google/gopacket"
    "github.com/google/gopacket/layers"
    "github.com/google/gopacket/pcap"
)

func main() {
    var wg sync.WaitGroup

    var dir = flag.String("dir", "../pcap", "input dir")
    var threadNum = flag.Int("threads", 40, "input thread number")
    flag.Parse()
    fmt.Printf("dir=%s, threadNum=%d\n", *dir, *threadNum)

    pcapFileList, err := ioutil.ReadDir(*dir)
    if err != nil {
        panic(err)
    }

    log.Printf("start. file number=%d.", len(pcapFileList))

    fileNumPerRoutine := len(pcapFileList) / *threadNum
    lastFileNum := len(pcapFileList) % *threadNum

    // split files to different routine
    // each routine only process files which belong to itself
    if fileNumPerRoutine > 0 {
        for i := 0; i < *threadNum; i++ {
            start := fileNumPerRoutine * i
            end := fileNumPerRoutine * (i + 1)
            if lastFileNum > 0 && i == (*threadNum-1) {
                end = len(pcapFileList)
            }
            // fmt.Printf("start=%d, end=%d\n", start, end)
            wg.Add(1)
            go checkPcapRoutine(i, &wg, dir, pcapFileList[start:end])
        }
    }

    wg.Wait()
    log.Printf("end.")
}

func checkPcapRoutine(id int, wg *sync.WaitGroup, dir *string, pcapFileList []os.FileInfo) {
    defer wg.Done()

    for _, p := range pcapFileList {
        if !strings.HasSuffix(p.Name(), "pcap") {
            continue
        }
        pcapFile := *dir + "/" + p.Name()
        log.Printf("checkPcapRoutine(%d): process %s.", id, pcapFile)

        handle, err := pcap.OpenOffline(pcapFile)
        if err != nil {
            log.Printf("error=%s.", err)
            return
        }
        defer handle.Close()

        packetSource := gopacket.NewPacketSource(handle, handle.LinkType())

        // Per my test, if I don't parse packets, it is very fast, even use only 1 routine, so IO should not be the bottleneck.
        // What puzzles me is that every routine has their own packets, each routine is independent, but it still seems to be processed serially.
        // This is the first time I use gopacket, maybe used wrong parameter?
        for packet := range packetSource.Packets() {
            gtpLayer := packet.Layer(layers.LayerTypeGTPv1U)
            lays := packet.Layers()
            outerIPLayer := lays[1]
            outerIP := outerIPLayer.(*layers.IPv4)

            if gtpLayer == nil && (outerIP.Flags&layers.IPv4MoreFragments != 0) && outerIP.Length < 56 {
                log.Panicf("file:%s, idx=%d may leakage.", pcapFile, j+1)
                break
            }
        }
    }
}

解决方案

要并行运行两个或多个任务，执行这些任务所需的操作必须具有不依赖于彼此或某些外部资源的属性，这些资源被称为这些任务共享。

在现实世界中，真正完全独立的任务是很少见的（如此罕见，甚至有一个专门的名称来描述此类任务的类别：据说它们是 embarrasingly parallel），但是当任务的依赖程度彼此的进度和竞争访问共享资源低于某个阈值，添加更多“工作者”（goroutine）可能会缩短完成一组任务所需的总时间。

注意这里的“可能”：例如，您的存储设备及其上的文件系统以及与文件系统一起工作的内核数据结构和代码，并且存储设备是所有您的 goroutine 都必须访问的共享介质。这种介质的吞吐量和延迟都有一定的限制；基本上，您每秒只能从该介质读取 M 字节，无论您有一个读取器充分利用该带宽，还是有 N 个读取器（每个读取器都利用大约 M/N 的量），这并不重要：您在物理上读取速度不能超过 M BPS 的限制。

此外，现实世界中最常见的资源在争夺时往往会降低其性能：例如，如果必须访问 locked 的资源，则主动想要获取锁的访问者越多，CPU 就越多时间花在锁管理代码上（当资源更复杂时——比如“存储设备上的文件系统——全部由内核管理”这种复杂的东西的集合体——分析它在被访问时如何降级同时变得更加复杂）。

TL;DR

我可以做出有根据的猜测，您的任务只是 I/O 限制，因为 goroutine 必须读取文件。

您可以通过修改代码来验证这一点，首先将所有文件提取到内存中，然后将缓冲区交给解析 goroutine。

您在案例中观察到的大量 CPU 消耗是一种转移注意力的现象：当代系统喜欢将 100% CPU 利用率视为“单个硬件处理线程的充分利用” —因此，如果您启用了 4 个 CPU 核心（例如启用了 HyperThreading™（或 AMD 提供的任何功能）），则系统的全部容量为 4×2=8，即 800%。
事实上，您看到的容量可能超过了理论容量（我们不知道），这可能是因为您的系统显示了所谓的“饥饿”：您有许多软件线程需要被执行，但等待它们的 CPU 时间，系统将其显示为疯狂的 CPU 利用率。

好了，本文到此结束，带大家了解了《多个go例程读取pcap文件不能提高性能？》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多Golang知识！