multithreading - 使用 WaitGroups 和 goroutines 优化多线程的正确方法？

Question

我正在努力使我的应用程序运行得尽可能快。我从 Google Cloud 购买了一个半强大的容器，我很想知道我每秒可以从这个程序中得到多少次迭代。但是，我是 Go 的新手，到目前为止，我的实现非常困惑并且运行不佳。

按照我现在的设置方式，它将以高速率开始(大约每秒 11,000 次迭代)，但随后会迅速减少到 2,000 次。我的目标是远远超过 11,000。此外，infofunc(i) 函数似乎跟不上快速的速度，并且对该函数使用 goroutine 会导致打印到控制台的重叠。此外，它有时会在 Wait 返回之前重用 WaitGroup。

我不喜欢成为要求被灌输代码的人，但我不知道如何实现它。在并行、多线程等方面似乎有很多不同的方法，这让我感到困惑。

import (
    "fmt"
    "math/big"
    "os"
    "os/exec"
    "sync"
    "time"
)

var found = 0
var pages_queried = 0
var start_time = time.Now()
var bignum = new(big.Int)
var foundAddresses = 0
var wg sync.WaitGroup
var set = make(map[string]bool)
var addresses = []string{"6ab42gyr", "lo08n4g6"}

func main() {
    bignum.SetString("1000000000000000000000000000", 10)
    pick := os.Args[1]
    kpp := 128
    switch pick {
    case "btc":
        i := new(big.Int)
        i, ok := i.SetString(os.Args[2], 10)
        if ok {
            cmd := exec.Command("clear")
            cmd.Stdout = os.Stdout
            cmd.Run()
            for i.Cmp(bignum) < 0 {
                wg.Add(1)
                go func(i *big.Int) {
                    defer wg.Done()
                    go printKeys(i.String(), kpp)
                    i.Add(i, big.NewInt(1))
                    pages_queried += 1
                    infofunc(i)
                }(i)
                wg.Wait()
            }
        }
    }
}

func infofunc(i *big.Int) {
    elapsed := time.Now().Sub(start_time)
    duration, _ := time.ParseDuration(elapsed.String())
    duration2 := int(duration.Seconds())
    if duration2 != 0 {
        fmt.Printf("\033[5;0H")
        fmt.Printf("Started at %s. Found: %d. Elapsed: %s. Queried: %d pages. Current page: %s. Rate: %d/s", start_time.String(), found, elapsed.String(), pages_queried, i.String(), (pages_queried / duration2))
    }
}

func printKeys(pageNumber string, keysPerPage int) {
    keys := generateKeys(pageNumber, keysPerPage)
    length := len(keys)
    var addressesLen = len(addresses)

    for i := 0; i < length; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            for ii := 0; ii < addressesLen; ii++ {
                wg.Add(1)
                go func(i int, ii int, keys []key) {
                    defer wg.Done()
                    for _, v := range addresses {
                        if set[keys[i].compressed] || set[keys[i].uncompressed] {
                            fmt.Print("Found an address: " + v + "!\n")
                            fmt.Printf("%v", keys[i])
                            fmt.Print("\n")
                            foundAddresses += 1
                            found += 1
                        }
                    }
                }(i, ii, keys)
            }
        }(i)
        foundAddresses = 0
    }
}

Answer 1

我不会使用全局 sync.WaitGroup，很难理解发生了什么。相反，只需在需要的地方定义它即可。

您正在循环 block 内调用 wg.Wait()。这基本上是在等待 goroutine 完成的每次迭代中阻塞循环。您真正想要的是生成所有 goroutine，然后等待它们完成。

if ok {
    cmd := exec.Command("clear")
    cmd.Stdout = os.Stdout
    cmd.Run()
    var wg sync.WaitGroup //I am about to spawn goroutines, I need to wait for them
    for i.Cmp(bignum) < 0 {
        wg.Add(1)
        go func(i *big.Int) {
            defer wg.Done()
            go printKeys(i.String(), kpp)
            i.Add(i, big.NewInt(1))
            pages_queried += 1
            infofunc(i)
        }(i)
    }
    wg.Wait() //Now that all goroutines are working, let's wait
}

当你有多个协程时，你无法避免打印重叠。如果这是一个问题，您可能会考虑使用 Go 的 log stdlib，它将为您添加时间戳。然后，您应该能够按时间顺序对它们进行排序。

无论如何，将代码拆分为更多的 goroutines 并不能确保加速。如果你试图解决的问题本质上是顺序的，那么更多的 goroutines 只会增加 Go 调度器的竞争和压力，导致相反的结果。 More details here.因此，infofunc 的 goroutine 将无济于事。但它可以通过使用记录器库而不是普通的 fmt 包来改进。

func infofunc(i *big.Int) {
    duration := time.Since(start_time).Seconds()
    if duration != 0 {
        log.Printf("\033[5;0H")
        log.Printf("Started at %s. Found: %d. Elapsed: %s. Queried: %d pages. Current page: %s. Rate: %d/s", start_time.String(), found, elapsed.String(), pages_queried, i.String(), (pages_queried / duration2))
    }
}

对于 printKeys，我不会创建那么多 goroutine，如果它们需要执行的工作受 CPU 限制，它们将无济于事，这里似乎就是这种情况。

func printKeys(pageNumber string, keysPerPage int) {
    keys := generateKeys(pageNumber, keysPerPage)
    length := len(keys)
    var addressesLen = len(addresses)
    var wg sync.WaitGroup //Local WaitGroup
    for i := 0; i < length; i++ {
        wg.Add(1)
        go func(i int) {  //This goroutine could be removed, in my opinion.
            defer wg.Done()
            for ii := 0; ii < addressesLen; ii++ {
                for _, v := range addresses {
                    if set[keys[i].compressed] || set[keys[i].uncompressed] {
                        log.Printf("Found an address: %v\n", v)
                        log.Printf("%v", keys[i])
                        log.Printf("\n")
                        foundAddresses += 1
                        found += 1
                    }
                }
            }
        }(i)
        foundAddresses = 0
    }
    wg.Wait()
}

我建议为这些函数编写基准测试，然后启用跟踪。通过这种方式，您应该了解您的代码大部分时间花在哪里。