Go使用協(xié)程批量獲取數(shù)據(jù)加快接口返回速度

更新時間：2023年02月07日 11:08:21 作者：HappyTeemo

這篇文章主要介紹了Go使用協(xié)程批量獲取數(shù)據(jù)加快接口返回速度,使用Go語言后，可以并發(fā)獲取，極大提升效率，需要的朋友可以參考下

使用channel

Copy Highlighter-hljs

package main

import (
   "fmt"
   "time"
)

func add2(a, b int, ch chan int) {
   c := a + b
   fmt.Printf("%d + %d = %d\n", a, b, c)
   ch <- 1 //執(zhí)行完了就寫一條表示自己完成了
}

func main() {
   start := time.Now()
   chs := make([]chan int, 10)
   for i := 0; i < 10; i++ {
      chs[i] = make(chan int)
      go add2(1, i, chs[i]) //分配了10個協(xié)程出去了
   }
   for _, ch := range chs {
      <-ch //循環(huán)等待，要每個完成才能繼續(xù)，不然就等待
   }
   end := time.Now()
   consume := end.Sub(start).Seconds()
   fmt.Println("程序執(zhí)行耗時(s)：", consume)
}

在每個協(xié)程的 add() 函數(shù)業(yè)務邏輯完成后，我們通過 ch <- 1 語句向對應的通道中發(fā)送一個數(shù)據(jù)。

在所有的協(xié)程啟動完成后，我們再通過 <-ch 語句從通道切片 chs 中依次接收數(shù)據(jù)（不對結果做任何處理，相當于寫入通道的數(shù)據(jù)只是個標識而已，表示這個通道所屬的協(xié)程邏輯執(zhí)行完畢）.

直到所有通道數(shù)據(jù)接收完畢，然后打印主程序耗時并退出。

使用WaitGroup

Add：WaitGroup 類型有一個計數(shù)器，默認值是0，我們可以通過 Add 方法來增加這個計數(shù)器的值，通常我們可以通過個方法來標記需要等待的子協(xié)程數(shù)量；
Done：當某個子協(xié)程執(zhí)行完畢后，可以通過 Done 方法標記已完成，該方法會將所屬 WaitGroup 類型實例計數(shù)器值減一，通?？梢酝ㄟ^ defer 語句來調用它；
Wait：Wait 方法的作用是阻塞當前協(xié)程，直到對應 WaitGroup 類型實例的計數(shù)器值歸零，如果在該方法被調用的時候，對應計數(shù)器的值已經是 0，那么它將不會做任何事情

package main

import (
   "fmt"
   "sync"
)

func addNum(a, b int, deferFunc func()) {
   defer func() {
      deferFunc()
   }()
   c := a + b
   fmt.Printf("%d + %d = %d\n", a, b, c)
}

func main() {
   var wg sync.WaitGroup
   wg.Add(10) //等于發(fā)了10個令牌
   for i := 0; i < 10; i++ {
      go addNum(i, 1, wg.Done) //每次執(zhí)行都消耗令牌
   }
   wg.Wait() //等待令牌消耗完
}

需要注意的是，該類型計數(shù)器不能小于0，否則會拋出如下 panic：

panic: sync: negative WaitGroup counter

應用到實踐

func GetManyBase(userIds []int64) []UserBase {
   userCaches := make([]UserBase, len(userIds))

   var wg sync.WaitGroup
   for index, userId := range userIds {
      wg.Add(1)
      go func(index int, userId int64, userCaches []UserBase) {
         userCaches[index] = NewUserCache(userId).GetBase() 
         wg.Done()
      }(index, userId, userCaches)
   }
   wg.Wait()

   return userCaches
}

這種寫法有兩個問題：
1.并發(fā)肯定帶來亂序，所以要考慮需要排序的業(yè)務場景。
2.map是線程不安全的，并發(fā)讀寫會panic。

優(yōu)化一下：

func GetManyBase(userIds []int64) []UserBase {
	userCaches := make([]UserBase, len(userIds))

	var scene sync.Map

	var wg sync.WaitGroup
	for index, userId := range userIds {
		wg.Add(1)
		go func(index int, userId int64, userCaches []UserBase) {
			scene.Store(userId, NewUserCache(userId).GetBase())
			wg.Done()
		}(index, userId, userCaches)
	}
	wg.Wait()

	i := 0
	for _, userId := range userIds {
		if value, ok := scene.Load(userId); ok {
			userCaches[i] = value.(UserBase)
		}
		i++
	}

	return userCaches
}

為什么不直接上鎖？