Как параллельный доступ к слайсам может быть элегантным и безопасным?

Go

бросать вопросы

Поскольку слайс/карта является ссылочным типом, функции golang вызываются по значению, а копия используемых параметров по-прежнему является исходным слайсом, а одновременный доступ к одному и тому же ресурсу приведет к состоянию гонки.

Посмотрите на следующий код:

package main

import (
    "fmt"
    "sync"
)

func main() {
    var (
        slc = []int{}
        n   = 10000
        wg  sync.WaitGroup
    )

    wg.Add(n)
    for i := 0; i < n; i++ {
        go func() {
            slc = append(slc, i)
            wg.Done()
        }()
    }
    wg.Wait()

    fmt.Println("len:", len(slc))
    fmt.Println("done")
}

// Output:
len: 8586
done

真实的输出并没有达到我们的预期，len(slice)

Итак, как решить эту проблему? map официально предоставляет решение sync.map начиная с версии 1.9, но если вы хотите получить одновременный доступ к слайсу, вам нужно спроектировать его самостоятельно. Вот два способа помочь вам решить эту проблему.

Вариант 1: Заблокировать 🔐

func main() {
	slc := make([]int, 0, 1000)
	var wg sync.WaitGroup
	var lock sync.Mutex

	for i := 0; i < 1000; i++ {
		wg.Add(1)
		go func(a int) {
			defer wg.Done()
      // 加🔐
			lock.Lock()
			defer lock.Unlock()
			slc = append(slc, a)
		}(i)
	
	}
   wg.Wait()
	fmt.Println(len(slc))
}

Преимущество заключается в том, что он относительно прост и подходит для сценариев с низкими требованиями к производительности.

Сценарий 2. Сериализация операций с использованием каналов

type ServiceData struct {
	ch   chan int // 用来 同步的channel
	data []int    // 存储数据的slice
}

func (s *ServiceData) Schedule() {
	// 从 channel 接收数据
	for i := range s.ch {
		s.data = append(s.data, i)
	}
}

func (s *ServiceData) Close() {
	// 最后关闭 channel
	close(s.ch)
}

func (s *ServiceData) AddData(v int) {
	s.ch <- v // 发送数据到 channel
}

func NewScheduleJob(size int, done func()) *ServiceData {
	s := &ServiceData{
		ch:   make(chan int, size),
		data: make([]int, 0),
	}

	go func() {
		// 并发地 append 数据到 slice
		s.Schedule()
		done()
	}()

	return s
}

func main() {
	var (
		wg sync.WaitGroup
		n  = 1000
	)
	c := make(chan struct{})

	// new 了这个 job 后，该 job 就开始准备从 channel 接收数据了
	s := NewScheduleJob(n, func() { c <- struct{}{} })

	wg.Add(n)
	for i := 0; i < n; i++ {
		go func(v int) {
			defer wg.Done()
			s.AddData(v)

		}(i)
	}

	wg.Wait()
	s.Close()
	<-c

	fmt.Println(len(s.data))
}

Реализация относительно сложная, преимущество в том, что производительность очень хорошая, и используется преимущество канала.

Приведенный выше код имеет более подробные комментарии, поэтому я не буду вдаваться в подробности.

Категории