高亮并行处理

Question

考虑到以下代码：

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    for i := 0; i < 3; i++ {
        go f(i)
    }

    // prevent main from exiting immediately
    var input string
    fmt.Scanln(&input)
}

func f(n int) {
    for i := 0; i < 10; i++ {
        dowork(n, i)
        amt := time.Duration(rand.Intn(250))
        time.Sleep(time.Millisecond * amt)
    }
}

func dowork(goroutine, loopindex int) {
    // simulate work
    time.Sleep(time.Second * time.Duration(5))
    fmt.Printf("gr[%d]: i=%d\n", goroutine, loopindex)
}

我是否可以假设“dowork”函数将并行执行？

这是一种实现并行的正确方法，还是更好地为每条河流使用通道和独立的“dowork”工作？

Answer 1

这个答案已经过时了。请改用 this answer .。

您的代码将同时运行，但不会并行运行。您可以通过设置GOMAXPROCS使其并行运行。

这里还不清楚您想要实现什么，但在我看来，这是实现并发性的一种非常有效的方法。

Answer 2

关于GOMAXPROCS，您可以在Go 1.5的发行版文档中找到这一点：

默认情况下，GOMAXPROCS将运行的Go程序设置为可用的核数；在以前的版本中，它默认为1。

关于防止main函数立即退出，您可以利用WaitGroup的Wait函数。

我编写了这个实用程序函数来帮助并行化一组函数：

import "sync"

// Parallelize parallelizes the function calls
func Parallelize(functions ...func()) {
    var waitGroup sync.WaitGroup
    waitGroup.Add(len(functions))

    defer waitGroup.Wait()

    for _, function := range functions {
        go func(copy func()) {
            defer waitGroup.Done()
            copy()
        }(function)
    }
}

所以在你的情况下，我们可以这么做

func1 := func() {
    f(0)
}

func2 = func() {
    f(1)
}

func3 = func() {
    f(2)
}

Parallelize(func1, func2, func3)

如果您想使用并行化函数，您可以在这里找到它-- https://github.com/shomali11/util

Answer 3

f()将同时执行，但许多dowork()将在每个f()中依次执行。等待stdin也不是确保例程完成执行的正确方法。当f()完成时，您必须旋转一个通道，每个true都可以推入一个f()。在main()的末尾，你必须等待通道上的true的n个数。n是你旋转出来的f()的数目。