给出以下代码:
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”函数将并行执行吗?
这是实现并行性的正确方法,还是使用通道并为每个 goroutine 分离“dowork”工作人员更好?
关于
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(f func()) {
defer waitGroup.Done()
f()
}(function)
}
}
所以对于你的情况,我们可以这样做
func1 := func() {
f(0)
}
func2 = func() {
f(1)
}
func3 = func() {
f(2)
}
Parallelize(func1, func2, func3)
如果您想使用Parallelize功能,可以在这里找到它https://github.com/shomali11/util
这个答案已经过时了。请参阅此答案。
您的代码将并发运行,但不是并行运行。您可以通过设置
GOMAXPROCS
使其并行运行。
目前尚不清楚您到底想在这里完成什么,但对我来说,这似乎是实现并发的完全有效的方法。
f()
将同时执行,但许多dowork()
将在每个f()
内顺序执行。等待 stdin 也不是确保例程完成执行的正确方法。您必须启动一个通道,当 f()
完成时,每个 true
都会推动 f()
。
在 main()
结束时,您必须在频道上等待 n 个 true
。 n 是您旋转的 f()
的数量。
这在我刚开始时对我很有帮助。
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)
}
“传统的基于集群的系统(例如超级计算机)使用 MPI 在处理器之间采用并行执行。MPI 是在不同处理器上的操作系统实例中执行的进程之间的通信接口;它不支持其他进程操作,例如调度。(冒着使事情进一步复杂化的风险,因为 MPI 进程是由操作系统执行的,所以单个处理器可以运行多个 MPI 进程和/或单个 MPI 进程也可以执行多个线程!)”
您可以在末尾添加一个循环,以阻塞直到作业完成:
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 }
}
}