我正在尝试了解 go-routines 的工作原理。这是一些代码:

//parallelSum.go
func sum(a []int, c chan<- int, func_id string) {
    sum := 0
    for _, n := range a {
        sum += n
    }
    log.Printf("func_id %v is DONE!", func_id)
    c <- sum
}   
func main() {
    ELEM_COUNT := 10000000
    test_arr := make([]int, ELEM_COUNT)
    for i := 0; i < ELEM_COUNT; i++ {
        test_arr[i] = i * 2 
    }
    c1 := make(chan int)
    c2 := make(chan int)
    go sum(test_arr[:len(test_arr)/2], c1, "1")
    go sum(test_arr[len(test_arr)/2:], c2, "2")
    x := <-c1
    y := <-c2

    //x, y := <-c, <-c
    log.Printf("x= %v, y = %v, sum = %v", x, y, x+y)
}   

以上程序运行良好并返回输出。我有同一个程序的迭代版本:

//iterSum.go
func sumIter(a []int, c *int, func_id string) {
    sum := 0
    log.Printf("entered the func %s", func_id)
    for _, n := range a { 
        sum += n
    }   
    log.Printf("func_id %v is DONE!", func_id)
    *c = sum 
}
func main() {
    */
    ELEM_COUNT := 10000000
    test_arr := make([]int, ELEM_COUNT)
    for i := 0; i < ELEM_COUNT; i++ {
        test_arr[i] = i * 2
    }
    var (
        i1 int
        i2 int
    )   
    sumIter(test_arr[:len(test_arr)/2], &i1, "1")
    sumIter(test_arr[len(test_arr)/2:], &i2, "2")
    x := i1
    y := i2

    log.Printf("x= %v, y = %v, sum = %v", x, y, x+y)
} 

我将程序运行了 20 次，并对每个程序的运行时间取平均值。我看平均值几乎相等？并行化不应该让事情变得更快吗？我做错了什么？

这是运行它 20 次的 python 程序:

iterCmd = 'go run iterSum.go'
parallelCmd = 'go run parallelSum.go'

runCount = 20


def analyzeCmd(cmd, runCount):
    runData = []
    print("running cmd (%s) for (%s) times" % (cmd, runCount))
    for i in range(runCount):
    ┆   start_time = time.time()
    ┆   cmd_out = subprocess.check_call(shlex.split(cmd))
        run_time = time.time() - start_time
    ┆   curr_data = {'iteration': i, 'run_time' : run_time}
    ┆   runData.append(curr_data)

    return runData

iterOut = analyzeCmd(iterCmd, runCount)
parallelOut = analyzeCmd(parallelCmd, runCount)

print("iter cmd data -->")
print(iterOut)

with open('iterResults.json', 'w') as f:
    json.dump(iterOut, f)

print("parallel cmd data -->")
print(parallelOut)

with open('parallelResults.json', 'w') as f:
    json.dump(parallelOut, f)

avg = lambda results: sum(i['run_time'] for i in results) / len(results)
print("average time for iterSum = %3.2f" % (avg(iterOut)))
print("average time for parallelSum = %3.2f" % (avg(parallelOut)))

这是 1 次运行的输出:

average time for iterSum = 0.27
average time for parallelSum = 0.29

最佳答案

所以，这里有几个问题。首先，您的 channel 在并发示例中没有被缓冲，这意味着接收方可能仍需要相互等待一段时间。其次，并发 并不意味着并行。您确定它们实际上是并行运行的，而不是简单地安排在同一个操作系统线程上吗？

也就是说，您这里的主要问题是您的 Python 代码在每次迭代中都使用 go run，这意味着您记录的绝大部分“运行时间”实际上是 编译 你的代码(go run 编译然后运行指定的文件，它特别设计不缓存任何文件)。如果要测试运行时间，请使用 Go's benchmark system ，而不是您自己拼凑的版本。你会得到更准确的结果。例如，除了编译瓶颈之外，也没有办法确定 Python 代码本身引入了多少瓶颈。

哦，您应该改掉使用函数引用参数作为“返回”值的方式的习惯。 Go 支持多次返回，因此 C 风格的就地修改参数通常被认为是一种反模式，除非有真正令人信服的理由这样做。

关于goroutine 阻塞和非阻塞用法，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/48530604/