并发性在Golang的循环中

各位小伙伴们，大家好呀！看看今天我又给各位带来了什么文章？本文标题是《并发性在Golang的循环中》，很明显是关于Golang的文章哈哈哈，其中内容主要会涉及到等等，如果能帮到你，觉得很不错的话，欢迎各位多多点评和分享！

我有一个项目，需要在 cpu 的多个核心上运行它以获得更快的速度。我在fortran中使用过omplib，但我不熟悉golang并行性。我尝试了 goroutine，但是出了问题，弄得一团糟，我得到了错误的结果。这是我的代码：

package main

import (
    "bufio"
    "fmt"
    "log"
    "math"
    "math/rand"
    "os"

    "time"
)

const (
    n_particles int     = 2048
    n_steps     int     = 1000000
    dt          float64 = 1.0
    v0          float64 = 0.50
    radius      float64 = 1.0
    f_intensity float64 = 1.8
    scale       float64 = 32.0
    alpha       float64 = 1.0 / 36.0
)

var (
    x      [n_particles + 1]float64
    y      [n_particles + 1]float64
    angles [n_particles + 1]float64
    vx     [n_particles + 1]float64
    vy     [n_particles + 1]float64
    order  [n_steps + 1]float64
)

func main() {
    /////randomizer
    vstart := time.now()
    rsource := rand.newsource(time.now().unixnano())
    randomizer := rand.new(rsource)

    for i := 0; i <= n_particles; i++ {
        x[i] = (randomizer.float64()) * scale
        y[i] = (randomizer.float64()) * scale
        angles[i] = (randomizer.float64()) * math.pi * 2
        sin, cos := math.sincos(angles[i])
        vx[i] = v0 * cos
        vy[i] = v0 * sin
    }
    //////main loop
    for i := 0; i <= n_steps; i++ {
        start := time.now()

        for j := 0; j <= n_particles; j++ {
            x[j] = x[j] + (vx[j] * dt)
            //x[j] = math.mod(x[j], scale)
            if x[j] < 0.0 {
                x[j] = x[j] + scale
            }
            if x[j] >= scale {
                x[j] = x[j] - scale
            }
            y[j] = y[j] + (vy[j] * dt)
            //y[j] = math.mod(x[j], scale)
            if y[j] < 0.0 {
                y[j] = y[j] + scale
            }
            if y[j] >= scale {
                y[j] = y[j] - scale
            }

        }
        type intpos struct {
            x, y int64
        }
        adjacencyindex := make(map[intpos][]int)
        ////getting each boxes particles
        for j := 0; j <= n_particles; j++ {
            // . . .
            ix, iy := int64(math.floor(x[j])), int64(math.floor(y[j]))                 // getting particle box
            adjacencyindex[intpos{ix, iy}] = append(adjacencyindex[intpos{ix, iy}], j) // adding particles to boxes
        }
        /////////
        m_angles := angles
        

现在我想并行运行以下循环：

////particle loop - I WANT FOLLOWING LOOP PARALLEL

    for j := 0; j <= n_particles; j++ {

        sumanglesx := 0.0
        sumanglesy := 0.0
        ix, iy := int64(math.Floor(x[j])), int64(math.Floor(y[j]))
        // fxi = math.Floor(x[j])
        // fyi = math.Floor(y[j])

        for dx := -1; dx <= 1; dx++ {
            for dy := -1; dy <= 1; dy++ {
                adjacentParticles := adjacencyIndex[intpos{ix + int64(dx), iy + int64(dy)}]

                for _, k := range adjacentParticles {

                    dist := ((x[k] - x[j]) * (x[k] - x[j])) + ((y[k] - y[j]) * (y[k] - y[j]))

                    if dist < radius {

                        sy, sx := math.Sincos(angles[k])

                        if k <= j {
                            sumanglesx = sumanglesx + sx
                            sumanglesy = sumanglesy + sy
                        } else {
                            sx = alpha * sx
                            sy = alpha * sy
                            sumanglesx = sumanglesx + sx
                            sumanglesy = sumanglesy + sy
                        }
                    }
                }
            }
        }
        bsource := rand.NewSource(time.Now().UnixNano())
        bandomizer := rand.New(bsource)
        sumanglesy = sumanglesy
        sumanglesx = sumanglesx
        r_angles := math.Atan2(sumanglesy, sumanglesx)
    }
}
}

我指定了一个应该并行运行的循环。

正确答案

这里有两种可以尝试的方法：https://play.golang.org/p/O1uB2zzJEC5

package main

import (
    "fmt"
    "sync"
)

func main() {
  waitGroupApproach()
  channelApproach()
}

func waitGroupApproach() {
    fmt.Println("waitGroupApproach")
    var waitgroup sync.WaitGroup
    
    result_table := make([]int, 6, 6)
    
    for j := 0; j <= 5; j++ {
        waitgroup.Add(1)
        
        go func(index int) {
            fmt.Println(index) // try putting here `j` instea of `index`
            result_table[index] = index*2
        
            waitgroup.Done()
        }(j) // you have to put any for-loop variables into closure
        // because otherwsie all routines inside will likely get the last j == n_particles + 1
        // as they will likely run after the loop has finished
    }
    
    fmt.Println("waiting")
    waitgroup.Wait()
    // process results further
    fmt.Println("finished")
    fmt.Println(result_table)
}

func channelApproach() {
    fmt.Println("\nchannelApproach")
    
    type intpos struct {
            x, y, index int
        }

    results := make(chan intpos)

    // initialize routines
    for j := 0; j <= 5; j++ {
        go func(index int) {
            // do processing
            results <- intpos{index*2, index*3, index}          
        }(j)
    }
    fmt.Println("Waiting..")
    
    // collect results, iterate the same number of times
    result_table := make([]int, 6)
    for j := 0; j <= 5; j++ {
        r := <- results
        // watch out order, migth not be the same as in invocation, 
        // so that's why I store j in results as well
        fmt.Println(r.index, r.x, r.y)
        result_table[r.index] = r.x
    }
    fmt.Println("Finished..")
    fmt.Println(result_table)
}

我更喜欢通道方法，因为它对我来说更惯用，并且可以更轻松地处理恐慌、错误情况等。

文中关于的知识介绍，希望对你的学习有所帮助！若是受益匪浅，那就动动鼠标收藏这篇《并发性在Golang的循环中》文章吧，也可关注golang学习网公众号了解相关技术文章。