Обновление фрагмента горутины

Срез распределяется между несколькими горутинами. При обновлении среза необходимо обеспечить взаимное исключение. Другими словами, это должно работать:

func func1(mmrpList *[]int, mmrpLock *sync.Mutex, ch1 <-chan int, wg *sync.WaitGroup) {

    defer wg.Done()

    for dwp := range ch1 {
        mmrpLock.Lock()
        *mmrpList = append(*mmrpList, dwp)
        mmrpLock.Unlock()
    }
}

Это также означает, что вам нужно создать один мьютекс и передать его всем горутинам.

Тем не менее, обычно это не то, как вы хотите это сделать. Просто нет смысла добавлять несколько горутин к одному фрагменту. Это не то, что вы хотите выполнять одновременно из-за последовательного характера добавления к срезу.

Что вы можете сделать, так это иметь одну горутину, которая добавляется к срезу, но несколько горутин, записывающих в канал, что-то вроде:

// Start multiple goroutines to write to ch1
wg:=sync.WaitGroup{}
for i:=0;i<n;i++ {
   wg.Add(1)
   go func() {
      defer wg.Done()
      generateData(ch1)
   }()
}

// Wait for all writers to complete and close the channel
go func() {
   wg.Wait()
   close(ch1)
}()

for data:=range ch1 {
   mmrpList=append(mmrpList,data)
}

Таким образом, вам не потребуется сериализовать доступ к срезу.

Возможно, вы ищете трубопроводы ( Go Playground):

package main

import (
    "fmt"
)

func main() {
    dwpList := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

    ch1 := iterateSamples(dwpList)

    mmrpList := func1(ch1)

    fmt.Println(mmrpList)
}

func iterateSamples(dwpList []int) <-chan int {
    ch1 := make(chan int)

    go func() {
        for _, dwp := range dwpList {
            ch1 <- dwp
        }
        close(ch1)
    }()

    return ch1
}

func func1(ch1 <-chan int) []int {
    var mmrpList []int

    for dwp := range ch1 {
        mmrpList = append(mmrpList, dwp)
    }

    return mmrpList
}

Это читается довольно четко и не блокируется.

Если вы хотите собрать входные данные из нескольких источников (или распределить работу между несколькими работниками), см. главу «Разветвление, разветвление».

Хотя блокировки сами по себе неплохи, наличие нескольких горутин, конкурирующих за один и тот же ресурс (срез), защищенный блокировкой, может привести к худшей производительности, чем выделение одной горутины для выполнения задания.

См. также «Переосмысление классических шаблонов параллелизма».

Если вы хотите перебрать несколько списков, просто используйте merge из «Fan-out, fan-in » ( Go Playground):

package main

import (
    "fmt"
    "sync"
)

func main() {
    dwpList1 := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    dwpList2 := []int{11, 12, 13, 14, 15, 16, 17, 18, 19, 20}

    ch1 := iterateSamples(dwpList1)
    ch2 := iterateSamples(dwpList2)

    ch := merge(ch1, ch2)

    mmrpList := func1(ch)

    fmt.Println(mmrpList)
}

Эти шаблоны легко компонуются.

вы можете реализовать срез с помощью пакета sync.mutex, чтобы избежать состояния гонки и одновременного доступа к общим ресурсам в нескольких горутинах.

import (
    "fmt"
    "sync"
)

type myList struct {
    list []int
    lock *sync.Mutex
}

func (l *myList) Add(number int) {
    l.lock.Lock()
    defer l.lock.Unlock()
    l.list = append(l.list, number)
}

func (l myList) GetList() []int {
    l.lock.Lock()
    defer l.lock.Unlock()
    return l.list
}

func main() {
    dwpList := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}
    mmrpList := myList{
        list: []int{},
        lock: new(sync.Mutex),
    }

    var listchan = make(chan int)
    defer close(listchan)

    for i := 0; i <= 5; i++ {
        go func() {
            for num := range listchan {
                mmrpList.Add(num)
            }
        }()
    }

    for _, num := range dwpList {
        listchan <- num
    }

    fmt.Println(mmrpList.GetList())
}

в этом коде вы можете добавить элемент в срез в 5 одновременных горутинах и получить список в конце после завершения добавления элементов.