对象的并发性会显著降低执行速度

学习Golang要努力，但是不要急！今天的这篇文章《对象的并发性会显著降低执行速度》将会介绍到等等知识点，如果你想深入学习Golang，可以关注我！我会持续更新相关文章的，希望对大家都能有所帮助！

我已获得此代码，并被要求了解如何使用并发来加速该过程。

#include 
#include 
#include 
#include 

#define size 10000000

volatile float a[size];
volatile float b[size];

int main(int argc, char **argv)
{
  long int       i;
  double         sum;
  struct timeval time1, time2;

  srand(time(0));

  for (i = 0; i < size; i++)
  {
    a[i] = rand();
    b[i] = rand();
  }

  gettimeofday(&time1, 0); //original place

  sum = 0.0;
  
  for (i = 0; i < size; i++)
  {
    sum = sum + a[i]*b[i];
  }

  gettimeofday(&time2, 0);
  
  printf("elapsed time (us) = %d\n", (time2.tv_sec-time1.tv_sec)*1000000 + time2.tv_usec - time1.tv_usec);

  return 0;
}                

如果我运行代码，我会得到输出

elapsed time (us) = 26546

然后我用go写了一个类似的程序

package main

import (
    "fmt"
    "math/rand"
    "time"
)

const size int64 = 10000000

var (
    a = [size]float32{}
    b = [size]float32{}
)

func main() {
    var (
        i     int64
        sum   float32
        time1 time.time
        time2 time.time
    )

    rand.seed(time.now().unixnano())

    for i = 0; i < size; i++ {
        a[i] = rand.float32()
        b[i] = rand.float32()
    }

    time1 = time.now() //original place

    sum = 0.0

    for i = 0; i < size; i++ {
        sum = sum + a[i] + b[i]
    }

    time2 = time.now()

    fmt.printf("elapsed time (us) = %d\n", time2.sub(time1).microseconds())
}

我得到了这个输出（这比 c 版本快得多）

elapsed time (us) = 2462

我的工作是尝试通过并发来使其更快，并且我认为如果并行运行数组，则可以加快数组的创建速度，但是计时器仅在创建后启动。所以我真的不知道如何加快速度，因为这些值需要合并，这将是一个顺序过程。

因此，我将启动计时器移至创建时间并获取 c 程序：

elapsed time (us) = 172496

对于 go 程序：

elapsed time (us) = 247603

所以现在 go 正如预期的那样比 c 慢。

然后我尝试更改我的 go 程序以在其自己的 goroutine 中创建每个数组：

package main

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

const size int = 10000000

var (
    a = [size]float64{}
    b = [size]float64{}
)

func main() {
    var (
        wg    sync.waitgroup
        sum   float64
        time1 time.time
        time2 time.time
    )

    rand.seed(time.now().unixnano())

    wg.add(2)

    time1 = time.now()

    go func() {
        for i := 0; i < size; i++ {
            a[i] = rand.float64()
        }
        wg.done()
    }()

    go func() {
        for i := 0; i < size; i++ {
            b[i] = rand.float64()
        }
        wg.done()
    }()

    wg.wait()

    sum = 0.0

    for i := 0; i < size; i++ {
        sum = sum + a[i] + b[i]
    }

    time2 = time.now()

    fmt.printf("elapsed time (us) = %d\n", time2.sub(time1).microseconds())
}

我得到输出：

elapsed time (us) = 395808

这相当慢。我预计这与函数的调用和等待组逻辑有关。

然后我尝试使用频道。

这使得程序花费很长时间，并且代码也很长。

然后我尝试为每个协程添加字段本身

package main

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

const size int = 10000000

func main() {
    var (
        wg    sync.waitgroup
        sum   float64
        asum  float64
        bsum  float64
        time1 time.time
        time2 time.time
    )

    rand.seed(time.now().unixnano())

    wg.add(2)

    time1 = time.now()

    go func() {
        asum = 0
        for i := 0; i < size; i++ {
            asum = asum + rand.float64()
        }

        wg.done()
    }()

    go func() {
        bsum = 0
        for i := 0; i < size; i++ {
            bsum = bsum + rand.float64()
        }
        wg.done()
    }()

    wg.wait()

    sum = asum + bsum

    time2 = time.now()

    fmt.printf("elapsed time (us) = %d\n", time2.sub(time1).microseconds())
    fmt.println(sum)
}

返回

Elapsed time (us) = 395182
1.000137482475232e+07

我还必须使用总和才能运行该程序 - 这就是我打印它的原因。

所以我似乎无法让这个程序通过并发运行得更快。

有人给我提示吗？或者我应该在并发产生任何影响之前运行更多作业？难道只是因为在这种情况下我只处理 2 个作业，并且因为数组的处理速度非常快？

正确答案

并发加快了执行时间。

go程序：

已用时间（我们）= 130768

并发的go程序：

已用时间（我们）= 66947

要让每个 goroutine 都有自己的 rand.rand 实例，请使用 rand.new(src source)。

运行 c 程序的 go 版本。

x.go：

package main

import (
    "fmt"
    "math/rand"
    "time"
)

const size = 10000000

var (
    a = [size]float32{}
    b = [size]float32{}
)

func main() {
    start := time.now()

    r := rand.new(rand.newsource(time.now().unixnano()))
    for i := 0; i < size; i++ {
        a[i] = r.float32()
        b[i] = r.float32()
    }

    sum := 0.0
    for i := 0; i < size; i++ {
        sum += float64(a[i]) * float64(b[i])
    }

    since := time.since(start).microseconds()
    fmt.printf("elapsed time (us) = %d\n", since)
}

.

$ go build x.go && ./x
elapsed time (us) = 130768
$

运行 c 程序的并发 go 版本。

y.go：

package main

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

const size = 10000000

var (
    a = [size]float32{}
    b = [size]float32{}
)

func main() {
    start := time.now()

    var wg sync.waitgroup
    wg.add(2)
    go func() {
        defer wg.done()
        r := rand.new(rand.newsource(time.now().unixnano()))
        for i := 0; i < size; i++ {
            a[i] = r.float32()
        }
    }()
    go func() {
        defer wg.done()
        r := rand.new(rand.newsource(time.now().unixnano()))
        for i := 0; i < size; i++ {
            b[i] = r.float32()
        }
    }()
    wg.wait()

    sum := 0.0
    for i := 0; i < size; i++ {
        sum += float64(a[i]) * float64(b[i])
    }

    since := time.since(start).microseconds()
    fmt.printf("elapsed time (us) = %d\n", since)
}

.

$ go build y.go && ./y
Elapsed time (us) = 66947
$

今天带大家了解了的相关知识，希望对你有所帮助；关于Golang的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~