golang 實現(xiàn)并發(fā)求和

更新時間：2021年05月08日 11:23:00 作者：butterfly5211314

這篇文章主要介紹了golang 并發(fā)求和的實現(xiàn)方式，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧

使用golang并發(fā)求和，作為對golang并發(fā)的一個練習.

為了驗證結果的正確性，要給出最傳統(tǒng)的版本：

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這種“模式”可能太過麻煩，

看第三種

直接一個函數(shù)寫出來：

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并發(fā)讀寫。

最后一種方法有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()
}

最后測試如下：

首先創(chuàng)建一個slice, 放1e8(1億)個整數(shù)(范圍[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并發(fā)求和（競爭而非分段）

舉例

如果要求2個goroutine并發(fā)完成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 //避免數(shù)據(jù)競爭
			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)
}

以上為個人經(jīng)驗，希望能給大家一個參考，也希望大家多多支持腳本之家。如有錯誤或未考慮完全的地方，望不吝賜教。

您可能感興趣的文章: