我需要从另一个 goroutine 读取结构字段集，afaik 直接这样做，即使知道肯定会有 没有并发 访问(写入在读取发生之前完成，通过 发出信号chan struct{}) 可能导致数据过时

将指针发送到结构(在第一个 goroutine 中创建，在第二个 goroutine 中修改，由第三个 goroutine 读取)解决可能的陈旧问题，考虑到我可以保证没有并发访问？

我想避免复制，因为结构很大并且包含巨大的 Bytes.Buffer 填充在第二个 goroutine 中，我需要从第三个 goroutine 开始读取

有一个锁定选项，但考虑到我知道不会有并发访问，这似乎有点矫枉过正

最佳答案

这个有很多答案，这取决于你的数据结构和程序逻辑。

参见:How to lock/synchronize access to a variable in Go during concurrent goroutines?
和:How to use RWMutex in Golang?

1- 使用 Stateful Goroutines和 channel
2- 使用 sync.Mutex
3- 使用同步/原子
4- 使用 WaitGroup
5- 使用程序逻辑( Semaphore )
...

1:Stateful Goroutines和 channel :
我模拟了非常相似的示例(假设您想从一个 SSD 读取并以不同的速度写入另一个 SSD):
在此示例代码中，一个 goroutine(名为 write)做一些工作准备数据并填充 big struct，另一个 goroutine(名为 read)从 big struct 读取数据然后做一些工作，以及 manger goroutine，保证不会并发访问相同的数据. 三个 goroutines 之间的通信是通过 channel 完成的。在您的情况下，您可以使用 channel 数据指针或全局结构，例如此示例。
输出将是这样的:
平均值= 36.6920166015625 标准偏差= 6.068973186592054

我希望这能帮助你理解这个想法。
工作示例代码:

package main

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

type BigStruct struct {
    big     []uint16
    rpos    int
    wpos    int
    full    bool
    empty   bool
    stopped bool
}

func main() {
    wg.Add(1)
    go write()
    go read()
    go manage()
    runtime.Gosched()
    stopCh <- <-time.After(5 * time.Second)
    wg.Wait()
    mean := Mean(hist)
    stdev := stdDev(hist, mean)
    fmt.Println("mean=", mean, "stdev=", stdev)
}

const N = 1024 * 1024 * 1024

var wg sync.WaitGroup
var stopCh chan time.Time = make(chan time.Time)

var hist []int = make([]int, 65536)

var s *BigStruct = &BigStruct{empty: true,
    big: make([]uint16, N), //2GB
}

var rc chan uint16 = make(chan uint16)
var wc chan uint16 = make(chan uint16)

func next(pos int) int {
    pos++
    if pos >= N {
        pos = 0
    }
    return pos
}

func manage() {
    dataReady := false
    var data uint16
    for {
        if !dataReady && !s.empty {
            dataReady = true
            data = s.big[s.rpos]
            s.rpos++
            if s.rpos >= N {
                s.rpos = 0
            }
            s.empty = s.rpos == s.wpos
            s.full = next(s.wpos) == s.rpos
        }
        if dataReady {
            select {
            case rc <- data:
                dataReady = false
            default:
                runtime.Gosched()
            }
        }
        if !s.full {
            select {
            case d := <-wc:
                s.big[s.wpos] = d
                s.wpos++
                if s.wpos >= N {
                    s.wpos = 0
                }
                s.empty = s.rpos == s.wpos
                s.full = next(s.wpos) == s.rpos
            default:
                runtime.Gosched()
            }
        }
        if s.stopped {
            if s.empty {
                wg.Done()
                return
            }
        }

    }
}

func read() {
    for {
        d := <-rc
        hist[d]++
    }
}

func write() {
    for {
        wc <- uint16(rand.Intn(65536))
        select {
        case <-stopCh:
            s.stopped = true
            return
        default:
            runtime.Gosched()
        }
    }
}

func stdDev(data []int, mean float64) float64 {
    sum := 0.0
    for _, d := range data {
        sum += math.Pow(float64(d)-mean, 2)
    }
    variance := sum / float64(len(data)-1)
    return math.Sqrt(variance)
}
func Mean(data []int) float64 {
    sum := 0.0
    for _, d := range data {
        sum += float64(d)
    }
    return sum / float64(len(data))
}

5:某些用例的另一种方式(更快):
这是另一种使用共享数据结构进行读取作业/写入作业/处理作业的方法，它在第一篇文章中是分开的，现在在这里做同样的 3 个作业没有 channel 并且没有互斥锁 .

工作样本:

package main

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

type BigStruct struct {
    big     []uint16
    rpos    int
    wpos    int
    full    bool
    empty   bool
    stopped bool
}

func manage() {
    for {
        if !s.empty {
            hist[s.big[s.rpos]]++ //sample read job with any time len
            nextPtr(&s.rpos)
        }
        if !s.full && !s.stopped {
            s.big[s.wpos] = uint16(rand.Intn(65536)) //sample wrire job with any time len
            nextPtr(&s.wpos)
        }
        if s.stopped {
            if s.empty {
                return
            }
        } else {
            s.stopped = time.Since(t0) >= 5*time.Second
        }
    }
}

func main() {
    t0 = time.Now()
    manage()
    mean := Mean(hist)
    stdev := StdDev(hist, mean)
    fmt.Println("mean=", mean, "stdev=", stdev)
    d0 := time.Since(t0)
    fmt.Println(d0) //5.8523347s
}

var t0 time.Time

const N = 100 * 1024 * 1024

var hist []int = make([]int, 65536)

var s *BigStruct = &BigStruct{empty: true,
    big: make([]uint16, N), //2GB
}

func next(pos int) int {
    pos++
    if pos >= N {
        pos = 0
    }
    return pos
}
func nextPtr(pos *int) {
    *pos++
    if *pos >= N {
        *pos = 0
    }

    s.empty = s.rpos == s.wpos
    s.full = next(s.wpos) == s.rpos
}

func StdDev(data []int, mean float64) float64 {
    sum := 0.0
    for _, d := range data {
        sum += math.Pow(float64(d)-mean, 2)
    }
    variance := sum / float64(len(data)-1)
    return math.Sqrt(variance)
}
func Mean(data []int) float64 {
    sum := 0.0
    for _, d := range data {
        sum += float64(d)
    }
    return sum / float64(len(data))
}

关于Golang 在 goroutine 之间共享大量数据，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/37371206/