go - 以下实现是否使我的代码并行？

问题描述

我在 Go 中有一个任务是并行化给定的代码循环。我不确定我的代码是否是并行的。

我尝试简单地将我拥有的数组分成两半，并在两半上使用 go 例程。

package main

import (
    "fmt"
    "math"
)

type Body struct {
    x, y, vx, vy, mass float64
    r, g, b uint
}

func main() {
    var count uint
    var radius float64
    done := make(chan bool)
    fmt.Scan(&count, &radius)
    bodies := make([]Body, count)
    for i := range bodies {
        b := &bodies[i]
        fmt.Scan(&b.x, &b.y, &b.vx, &b.vy, &b.mass, &b.r, &b.g, &b.b)
    }

    updatedBodies := make([]Body, count)
    copy(updatedBodies, bodies)
    mid := len(updatedBodies)/2


    go func(){
    for i := range updatedBodies[mid:] {
        b := &updatedBodies[i+mid]
        for _, ob := range bodies {
            dx, dy := ob.x - b.x, ob.y - b.y
            if dist := math.Sqrt(dx*dx + dy*dy); dist > 1 { // far enough
                accel := 0.0000000000667 * ob.mass / (dist * dist * dist)
                b.vx += accel * dx
                b.vy += accel * dy
            }
        }
        b.x += b.vx
        b.y += b.vy

    }
    done <- true
}()
    go func(){
        for i := range updatedBodies[:mid] {
        b := &updatedBodies[i]
        for _, ob := range bodies {
            dx, dy := ob.x - b.x, ob.y - b.y
            if dist := math.Sqrt(dx*dx + dy*dy); dist > 1 { // far enough
                accel := 0.0000000000667 * ob.mass / (dist * dist * dist)
                b.vx += accel * dx
                b.vy += accel * dy
            }
        }
        b.x += b.vx
        b.y += b.vy

    }
    done <- true
}()

    <- done
    <- done
    fmt.Println(count)
    fmt.Println(radius)
    for _, b := range updatedBodies {
        fmt.Println(b.x, b.y, b.vx, b.vy, b.mass, b.r, b.g, b.b)
    }
}

for i := range updatedBodies {
        b := &updatedBodies[i]
        for _, ob := range bodies {
            dx, dy := ob.x - b.x, ob.y - b.y
            if dist := math.Sqrt(dx*dx + dy*dy); dist > 1 { // far enough
                accel := 0.0000000000667 * ob.mass / (dist * dist * dist)
                b.vx += accel * dx
                b.vy += accel * dy
            }
        }
        b.x += b.vx
        b.y += b.vy

    }

我问了一位教授关于代码的问题，他说我必须递归地运行一个 go 例程才能使循环并行。

标签： goparallel-processing

您的代码确实同时运行*，但不一定以非常优化的方式运行。您实际上已将工作负载分成两部分，并且同时运行两部分。

[教授] 说我必须递归地运行一个 go 例程来使循环并行。

这不是真的，但我不知道你的教授说的确切的话，所以他可能没有对你撒谎。他显然有某种递归解决方案。我不会在这里使用递归，但这将是一种方式。

很难提供您的教授正在寻找的答案。最好的建议是请你的教授解释他的意图。

*并发不是并行。请阅读/观看此。

go - 以下实现是否使我的代码并行？

问题描述

解决方案

推荐阅读