golang并发求和

使用golang并发求和，作为对golang并发的一个练习.
为了验证结果的正确性，要给出最传统的版本：

func sum1(data []int) int {
	s := 0
	l := len(data)

	for i := 0; i < l; i++ {
		s += data[i]
	}
	return s
}

第二种方法，使用N个goroutine，然后将N个分段的和写入N个channel中：

func sum2(data []int) int {
	s := 0
	l := len(data)
	const N = 5
	seg := l / N
	var chs [N]<-chan int

	for i := 0; i < N; i++ {
		chs[i] = worker(data[i*seg : (i+1)*seg])
	}

	for i := 0; i < N; i++ {
		s += <-chs[i]
	}

	return s
}

func worker(s []int) <-chan int {
	out := make(chan int)

	go func() {
		length := len(s)
		sum := 0
		for i := 0; i < length; i++ {
			sum += s[i]
		}
		out <- sum
	}()
	return out
}

对于一个求和的任务来说，用worker这种“模式”可能太过麻烦，
看第三种，直接一个函数写出来：

func sum3(data []int) int {
	s := 0
	l := len(data)
	const N = 5
	seg := l / N

	var mu sync.Mutex
	var wg sync.WaitGroup
	wg.Add(N) // 直接加N个

	for i := 0; i < N; i++ {
		go func(ii int) {
			tmpS := data[ii*seg : (ii+1)*seg]
			ll := len(tmpS)
			mu.Lock()
			for i := 0; i < ll; i++ {
				s += tmpS[i]
			}
			mu.Unlock()
			wg.Done() // 一个goroutine运行完
		}(i)
	}
	wg.Wait() // 等N个goroutine都运行完

	return s
}

注意sum3要在读写s的地方加锁，因为s可能被多个goroutine并发读写。

最后一种方法有data race问题，不过运行结果是对的，看一下思路：

var sum4Tmp int
var sum4mu sync.Mutex

// 这个有data race问题，可以用WaitGroup改，只是提供一种思路
func sum4(data []int) int {
	//s := 0
	l := len(data)
	const N = 5
	seg := l / N

	for i := 0; i < N; i++ {
		go subsum4(data[i*seg : (i+1)*seg])
	}

	// 这里是>1，因为要排除main
	// 这种方法不可靠，只是一种思路
	for runtime.NumGoroutine() > 1 {
	}

	// go run -race sum.go会报data race问题
	// main goroutine对它读
	// 别的goroutine会对它写（go subsum4)
	return sum4Tmp
}

func subsum4(s []int) {
	length := len(s)
	sum := 0

	sum4mu.Lock()
	for i := 0; i < length; i++ {
		sum += s[i]
	}
	sum4Tmp = sum4Tmp + sum
	defer sum4mu.Unlock()
}

最后测试如下：
首先创建一个slice, 放1e8(1亿)个整数(范围[0,10))进去,
然后用4种方法进行计算。

func calcTime(f func([]int) int, arr []int, tag string) {
	t1 := time.Now().UnixNano()

	s := f(arr)
	t2 := time.Now().UnixNano() - t1
	fmt.Printf("%15s: time: %d, sum: %d\n", tag, t2, s)
}

func main() {
	const MAX = 1e8 // 1亿
	arr := make([]int, MAX)

	for i := 0; i < MAX; i++ {
		arr[i] = rand.Intn(10)
	}

	calcTime(sum1, arr, "for")
	calcTime(sum2, arr, "worker")
	calcTime(sum3, arr, "WaitGroup")
	calcTime(sum4, arr, "NumGoroutine")
}

我的笔记本输出结果：

           for: time: 61834200, sum: 450032946
        worker: time: 51861100, sum: 450032946
     WaitGroup: time: 153628200, sum: 450032946
  NumGoroutine: time: 63791300, sum: 450032946

欢迎补充指正!

猜你喜欢