Parallel processing golang中的并行处理

给定以下代码：

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)
}

主程序包
进口(
“fmt”
“数学/兰德”
“时间”
)
func main（）{
对于i:=0；i<3；i++{
go f（i）
}
//防止主管道立即退出
变量输入字符串
fmt.扫描和输入
}
函数f（n int）{
对于i:=0；i<10；i++{
嫁妆（n，i）
金额：=持续时间（兰特国际（250））
time.Sleep（time.毫秒*amt）
}
}
func dowork（goroutine，loopindex int）{
//模拟工作
时间。睡眠（时间。秒*时间。持续时间（5））
fmt.Printf（“gr[%d]：i=%d\n”，goroutine，loopindex）
}

我可以假设“dowork”函数将并行执行吗

---

这是实现并行性的正确方法，还是为每个goroutine使用通道和单独的“dowork”worker更好？

这个答案已经过时了。请改为查看。

---

您的代码将并发运行，但不会并行运行。您可以通过设置

GOMAXPROCS

使其并行运行

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

f（）

将同时执行，但许多

dowork（）

将在每个

f（）

中顺序执行。等待stdin也不是确保例程完成执行的正确方法。您必须旋转一个通道，当

f（）

结束时，每个

f（）

都会将

true

推上。

---

在

main（）

的末尾，您必须等待频道上n个

true

。n是您已经旋转的

f（）

的数量。

关于

GOMAXPROCS

，您可以在Go 1.5的发行文档中找到：

默认情况下，Go程序运行时GOMAXPROCS设置为可用的内核数；在以前的版本中，它默认为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)

---

如果你想使用Parallelize函数，你可以在这里找到它

这在我刚开始的时候对我很有帮助

    package main

    import "fmt"

    func put(number chan<- int, count int) {
        i := 0
        for ; i <= (5 * count); i++ {
            number <- i
        }
        number <- -1
    }

    func subs(number chan<- int) {
        i := 10
        for ; i <= 19; i++ {
            number <- i
        }
    }

    func main() {
        channel1 := make(chan int)
        channel2 := make(chan int)
        done := 0
        sum := 0

        go subs(channel2)
        go put(channel1, 1)
        go put(channel1, 2)
        go put(channel1, 3)
        go put(channel1, 4)
        go put(channel1, 5)

        for done != 5 {
            select {
            case elem := <-channel1:
                if elem < 0 {
                    done++
                } else {
                    sum += elem
                    fmt.Println(sum)
                }
            case sub := <-channel2:
                sum -= sub
                fmt.Printf("atimta : %d\n", sub)
                fmt.Println(sum)
            }
        }
        close(channel1)
        close(channel2)
    }

主程序包
输入“fmt”
func put（number chan您可以在末尾添加一个循环，以阻止作业完成：

package main
import "time"

func f(n int, b chan bool) {
   println(n)
   time.Sleep(time.Second)
   b <- true
}

func main() {
   b := make(chan bool, 9)
   for n := cap(b); n > 0; n-- {
      go f(n, b)
   }
   for <-b {
      if len(b) == 0 { break }
   }
}

主程序包
导入“时间”
函数f（n int，b chan bool）{
println（n）
时间。睡眠（时间。秒）
b0；n--{
前进f（n，b）
}
为了以防万一，有人会觉得有趣：解释如何在Go中对循环进行并行处理。@rath非常感谢-该网站将证明对我来说是一个很棒的资源！
sync.WaitGroup
在这种情况下比频道更好。我遵循了上面提到的文章示例。我没有得到相同的输出。方法是按顺序执行的不是并行的。是否可以用它进行并行SQL查询？我会避免使用
copy
作为变量名，因为它会覆盖一个预先声明的标识符：。