Golang中的并发积分计算

Question

I tried to compute the integral concurrently, but my program ended up being slower than computing the integral with a normal for loop. What am I doing wrong?

package main

import (
    "fmt"
    "math"
    "sync"
    "time"
)

type Result struct {
    result float64
    lock sync.RWMutex
}

var wg sync.WaitGroup
var result Result

func main() {
    now := time.Now()
    a := 0.0
    b := 1.0
    n := 100000.0
    deltax := (b - a) / n
    wg.Add(int(n))
    for i := 0.0; i < n; i++ {
        go f(a, deltax, i)
    }
    wg.Wait()
    fmt.Println(deltax * result.result)
    fmt.Println(time.Now().Sub(now))
}

func f(a float64, deltax float64, i float64) {
    fx := math.Sqrt(a + deltax * (i + 0.5))
    result.lock.Lock()
    result.result += fx
    result.lock.Unlock()
    wg.Done()
}

Answer 1

Unless the time taken by the activity in the goroutine takes a lot more time than needed to switch contexts, carry out the task and use a mutex to update a value, it would be faster to do it serially.

Take a look at a slightly modified version. All I've done is add a delay of 1 microsecond in the f() function.

package main

import (
    "fmt"
    "math"
    "sync"
    "time"
)

type Result struct {
    result float64
    lock   sync.RWMutex
}

var wg sync.WaitGroup
var result Result

func main() {
    fmt.Println("concurrent")
    concurrent()
    result.result = 0
    fmt.Println("serial")
    serial()
}

func concurrent() {
    now := time.Now()
    a := 0.0
    b := 1.0
    n := 100000.0
    deltax := (b - a) / n
    wg.Add(int(n))
    for i := 0.0; i < n; i++ {
        go f(a, deltax, i, true)
    }
    wg.Wait()
    fmt.Println(deltax * result.result)
    fmt.Println(time.Now().Sub(now))
}

func serial() {
    now := time.Now()
    a := 0.0
    b := 1.0
    n := 100000.0
    deltax := (b - a) / n
    for i := 0.0; i < n; i++ {
        f(a, deltax, i, false)
    }
    fmt.Println(deltax * result.result)
    fmt.Println(time.Now().Sub(now))
}

func f(a, deltax, i float64, concurrent bool) {
    time.Sleep(1 * time.Microsecond)
    fx := math.Sqrt(a + deltax*(i+0.5))
    if concurrent {
        result.lock.Lock()
        result.result += fx
        result.lock.Unlock()
        wg.Done()
    } else {
        result.result += fx
    }
}

With the delay, the result was as follows (the concurrent version is much faster):

concurrent
0.6666666685900424
624.914165ms

serial
0.6666666685900422
5.609195767s

Without the delay:

concurrent
0.6666666685900428
50.771275ms

serial
0.6666666685900422
749.166µs

As you can see, the longer it takes to complete a task, the more sense it makes to do it concurrently, if possible.