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

欢迎补充指正！

补充：golang并发求和（竞争而非分段）

举例

如果要求2个goroutine并发完成1到100的和而不是分段的情况如何解决呢？

解决方案：

var wg sync.waitgroup
var ch chan int32
var receivech chan int32
func add(){
	var sum int32
	sum = 0
	loop:
	for {
		select {
		case val, ok := <-ch:
			if ok {
				atomic.addint32(&sum, val)
			} else {
				break loop
			}
		}
	}
	receivech <- sum
	wg.done()
}
func main() {
	wg.add(3)
	ch = make(chan int32)
	receivech = make(chan int32, 2)
	go func(){
		for i := 1; i <= 100; i++{
			n := i //避免数据竞争
			ch <- int32(n) 
		}
		close(ch)
		wg.done()
	}()
	go add()
	go add()
	wg.wait()
	close(receivech)
	var sum int32
	sum = 0
	for res := range receivech{
		sum += res
	}
	fmt.println("sum:",sum)
}

以上为个人经验，希望能给大家一个参考，也希望大家多多支持。如有错误或未考虑完全的地方，望不吝赐教。