尝试并行化的速度不够快

Question

我阅读了Go的并发模型，还看到了并发性和并行性之间的区别。为了测试并行执行，我编写了以下程序。package mainimport (    "fmt"    "runtime"    "time")const count = 1e8var buffer [count]intfunc main() {    fmt.Println("GOMAXPROCS: ", runtime.GOMAXPROCS(0))    // Initialise with dummy value    for i := 0; i < count; i++ {        buffer[i] = 3    }    // Sequential operation    now := time.Now()    worker(0, count-1)    fmt.Println("sequential operation: ", time.Since(now))    // Attempt to parallelize    ch := make(chan int, 1)    now = time.Now()    go func() {        worker(0, (count/2)-1)        ch <- 1    }()    worker(count/2, count-1)    <-ch    fmt.Println("parallel operation: ", time.Since(now))}func worker(start int, end int) {    for i := start; i <= end; i++ {        task(i)    }}func task(index int) {    buffer[index] = 2 * buffer[index]}但问题是：结果不是很令人愉快。GOMAXPROCS:  8sequential operation:  206.85msparallel operation:  169.028ms使用戈鲁丁确实可以加快速度，但还不够。我预计它的速度会接近两倍。我的代码和/或理解有什么问题？我怎样才能接近两倍的速度？

Answer 1

并行化功能强大，但很难在如此小的计算负载下看到。下面是一些结果差异较大的示例代码：

package main

import (

    "fmt"

    "math"

    "runtime"

    "time"

)

func calctest(nCPU int) {

    fmt.Println("Routines:", nCPU)

    ch := make(chan float64, nCPU)

    startTime := time.Now()

    a := 0.0

    b := 1.0

    n := 100000.0

    deltax := (b - a) / n

    stepPerCPU := n / float64(nCPU)

    for start := 0.0; start < n; {

        stop := start + stepPerCPU

        go f(start, stop, a, deltax, ch)

        start = stop

    }

    integral := 0.0

    for i := 0; i < nCPU; i++ {

        integral += <-ch

    }

    fmt.Println(time.Now().Sub(startTime))

    fmt.Println(deltax * integral)

}

func f(start, stop, a, deltax float64, ch chan float64) {

    result := 0.0

    for i := start; i < stop; i++ {

        result += math.Sqrt(a + deltax*(i+0.5))

    }

    ch <- result

}

func main() {

    nCPU := runtime.NumCPU()

    calctest(nCPU)

    fmt.Println("")

    calctest(1)

}

这是我得到的结果：

Routines: 8

853.181µs

Routines: 1

2.031358ms