如何使用 WaitGroups 和 goroutine 来提升多线程效率？

欢迎各位小伙伴来到golang学习网，相聚于此都是缘哈哈哈！今天我给大家带来《如何使用 WaitGroups 和 goroutine 来提升多线程效率？》，这篇文章主要讲到等等知识，如果你对Golang相关的知识非常感兴趣或者正在自学，都可以关注我，我会持续更新相关文章！当然，有什么建议也欢迎在评论留言提出！一起学习！

我正在努力让我的应用程序运行得尽可能快。我从 google cloud 购买了一个半强大的容器，我很想看看每秒可以从这个程序中获得多少次迭代。然而，我是 go 新手，到目前为止，我的实现非常混乱并且运行不佳。

按照我现在的设置方式，它会以很高的速率开始（每秒大约 11,000 次迭代），但随后会迅速降至 2,000 次。我的目标是远远超过 11,000 人。此外， infofunc(i) 函数似乎无法跟上快速速度，并且对该函数使用 goroutine 会导致打印到控制台的重叠。此外，它有时会在等待返回之前重用 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
    }
}

解决方案

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

您正在循环块内调用 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
}

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

无论如何，将代码拆分为更多 goroutine 并不能确保速度提升。如果你试图解决的问题本质上是顺序的，那么更多的 goroutine 只会给 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()
}

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

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于Golang的相关知识，也可关注golang学习网公众号。