Question

我正在尝试使我的应用程序尽快运行。我从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
    }
}

Answer 1

我不会使用全局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，它将为您添加时间戳。然后，您应该能够按时间顺序对其进行排序。

无论如何，将代码拆分为更多goroutines并不能确保速度提高。如果您要解决的问题本质上是顺序问题，那么更多的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()
}

我建议为这些功能编写一个基准，然后启用跟踪。通过这种方式，您应该了解大部分时间在代码上的花费。

使用WaitGroup和goroutine优化多线程的正确方法？

1 个答案: