go?zero微服務(wù)實戰(zhàn)性能優(yōu)化極致秒殺

更新時間：2022年07月14日 10:40:51 作者：kevinwan

這篇文章主要為大家介紹了go-zero微服務(wù)實戰(zhàn)性能優(yōu)化極致秒殺功能實現(xiàn)，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進(jìn)步，早日升職加薪

引言

上一篇文章中引入了消息隊列對秒殺流量做削峰的處理，我們使用的是Kafka，看起來似乎工作的不錯，但其實還是有很多隱患存在，如果這些隱患不優(yōu)化處理掉，那么秒殺搶購活動開始后可能會出現(xiàn)消息堆積、消費延遲、數(shù)據(jù)不一致、甚至服務(wù)崩潰等問題，那么后果可想而知。本篇文章我們就一起來把這些隱患解決掉。

批量數(shù)據(jù)聚合

在SeckillOrder這個方法中，每來一次秒殺搶購請求都往往Kafka中發(fā)送一條消息。假如這個時候有一千萬的用戶同時來搶購，就算我們做了各種限流策略，一瞬間還是可能會有上百萬的消息會發(fā)到Kafka，會產(chǎn)生大量的網(wǎng)絡(luò)IO和磁盤IO成本，大家都知道Kafka是基于日志的消息系統(tǒng)，寫消息雖然大多情況下都是順序IO，但當(dāng)海量的消息同時寫入的時候還是可能會扛不住。

那怎么解決這個問題呢？答案是做消息的聚合。之前發(fā)送一條消息就會產(chǎn)生一次網(wǎng)絡(luò)IO和一次磁盤IO，我們做消息聚合后，比如聚合100條消息后再發(fā)送給Kafka，這個時候100條消息才會產(chǎn)生一次網(wǎng)絡(luò)IO和磁盤IO，對整個Kafka的吞吐和性能是一個非常大的提升。其實這就是一種小包聚合的思想，或者叫Batch或者批量的思想。這種思想也隨處可見，比如我們使用Mysql插入批量數(shù)據(jù)的時候，可以通過一條SQL語句執(zhí)行而不是循環(huán)的一條一條插入，還有Redis的Pipeline操作等等。

那怎么來聚合呢，聚合策略是啥呢？聚合策略有兩個維度分別是聚合消息條數(shù)和聚合時間，比如聚合消息達(dá)到100條我們就往Kafka發(fā)送一次，這個條數(shù)是可以配置的，那如果一直也達(dá)不到100條消息怎么辦呢？通過聚合時間來兜底，這個聚合時間也是可以配置的，比如配置聚合時間為1秒鐘，也就是無論目前聚合了多少條消息只要聚合時間達(dá)到1秒，那么就往Kafka發(fā)送一次數(shù)據(jù)。聚合條數(shù)和聚合時間是或的關(guān)系，也就是只要有一個條件滿足就觸發(fā)。

在這里我們提供一個批量聚合數(shù)據(jù)的工具Batcher，定義如下

type Batcher struct {
  opts options
  Do       func(ctx context.Context, val map[string][]interface{})
  Sharding func(key string) int
  chans    []chan *msg
  wait     sync.WaitGroup
}

Do方法：滿足聚合條件后就會執(zhí)行Do方法，其中val參數(shù)為聚合后的數(shù)據(jù)

Sharding方法：通過Key進(jìn)行sharding，相同的key消息寫入到同一個channel中，被同一個goroutine處理

在merge方法中有兩個觸發(fā)執(zhí)行Do方法的條件，一是當(dāng)聚合的數(shù)據(jù)條數(shù)大于等于設(shè)置的條數(shù)，二是當(dāng)觸發(fā)設(shè)置的定時器

代碼實現(xiàn)比較簡單，如下為具體實現(xiàn)：

type msg struct {
  key string
  val interface{}
}
type Batcher struct {
  opts options
  Do       func(ctx context.Context, val map[string][]interface{})
  Sharding func(key string) int
  chans    []chan *msg
  wait     sync.WaitGroup
}
func New(opts ...Option) *Batcher {
  b := &Batcher{}
  for _, opt := range opts {
    opt.apply(&b.opts)
  }
  b.opts.check()
  b.chans = make([]chan *msg, b.opts.worker)
  for i := 0; i < b.opts.worker; i++ {
    b.chans[i] = make(chan *msg, b.opts.buffer)
  }
  return b
}
func (b *Batcher) Start() {
  if b.Do == nil {
    log.Fatal("Batcher: Do func is nil")
  }
  if b.Sharding == nil {
    log.Fatal("Batcher: Sharding func is nil")
  }
  b.wait.Add(len(b.chans))
  for i, ch := range b.chans {
    go b.merge(i, ch)
  }
}
func (b *Batcher) Add(key string, val interface{}) error {
  ch, msg := b.add(key, val)
  select {
  case ch <- msg:
  default:
    return ErrFull
  }
  return nil
}
func (b *Batcher) add(key string, val interface{}) (chan *msg, *msg) {
  sharding := b.Sharding(key) % b.opts.worker
  ch := b.chans[sharding]
  msg := &msg{key: key, val: val}
  return ch, msg
}
func (b *Batcher) merge(idx int, ch <-chan *msg) {
  defer b.wait.Done()
  var (
    msg        *msg
    count      int
    closed     bool
    lastTicker = true
    interval   = b.opts.interval
    vals       = make(map[string][]interface{}, b.opts.size)
  )
  if idx > 0 {
    interval = time.Duration(int64(idx) * (int64(b.opts.interval) / int64(b.opts.worker)))
  }
  ticker := time.NewTicker(interval)
  for {
    select {
    case msg = <-ch:
      if msg == nil {
        closed = true
        break
      }
      count++
      vals[msg.key] = append(vals[msg.key], msg.val)
      if count >= b.opts.size {
        break
      }
      continue
    case <-ticker.C:
      if lastTicker {
        ticker.Stop()
        ticker = time.NewTicker(b.opts.interval)
        lastTicker = false
      }
    }
    if len(vals) > 0 {
      ctx := context.Background()
      b.Do(ctx, vals)
      vals = make(map[string][]interface{}, b.opts.size)
      count = 0
    }
    if closed {
      ticker.Stop()
      return
    }
  }
}
func (b *Batcher) Close() {
  for _, ch := range b.chans {
    ch <- nil
  }
  b.wait.Wait()
}

使用的時候需要先創(chuàng)建一個Batcher，然后定義Batcher的Sharding方法和Do方法，在Sharding方法中通過ProductID把不同商品的聚合投遞到不同的goroutine中處理，在Do方法中我們把聚合的數(shù)據(jù)一次性批量的發(fā)送到Kafka，定義如下：

b := batcher.New(
  batcher.WithSize(batcherSize),
  batcher.WithBuffer(batcherBuffer),
  batcher.WithWorker(batcherWorker),
  batcher.WithInterval(batcherInterval),
)
b.Sharding = func(key string) int {
  pid, _ := strconv.ParseInt(key, 10, 64)
  return int(pid) % batcherWorker
}
b.Do = func(ctx context.Context, val map[string][]interface{}) {
  var msgs []*KafkaData
  for _, vs := range val {
    for _, v := range vs {
      msgs = append(msgs, v.(*KafkaData))
    }
  }
  kd, err := json.Marshal(msgs)
  if err != nil {
    logx.Errorf("Batcher.Do json.Marshal msgs: %v error: %v", msgs, err)
  }
  if err = s.svcCtx.KafkaPusher.Push(string(kd)); err != nil {
    logx.Errorf("KafkaPusher.Push kd: %s error: %v", string(kd), err)
  }
}
s.batcher = b
s.batcher.Start()

在SeckillOrder方法中不再是每來一次請求就往Kafka中投遞一次消息，而是先通過batcher提供的Add方法添加到Batcher中等待滿足聚合條件后再往Kafka中投遞。

err = l.batcher.Add(strconv.FormatInt(in.ProductId, 10), &KafkaData{Uid: in.UserId, Pid: in.ProductId})
if err!= nil {
    logx.Errorf("l.batcher.Add uid: %d pid: %d error: %v", in.UserId, in.ProductId, err)
}

降低消息的消費延遲

通過批量消息處理的思想，我們提供了Batcher工具，提升了性能，但這主要是針對生產(chǎn)端而言的。當(dāng)我們消費到批量的數(shù)據(jù)后，還是需要串行的一條條的處理數(shù)據(jù)，那有沒有辦法能加速消費從而降低消費消息的延遲呢？有兩種方案分別是：

增加消費者的數(shù)量
在一個消費者中增加消息處理的并行度

因為在Kafka中，一個Topci可以配置多個Partition，數(shù)據(jù)會被平均或者按照生產(chǎn)者指定的方式寫入到多個分區(qū)中，那么在消費的時候，Kafka約定一個分區(qū)只能被一個消費者消費，為什么要這么設(shè)計呢？我理解的是如果有多個Consumer同時消費一個分區(qū)的數(shù)據(jù)，那么在操作這個消費進(jìn)度的時候就需要加鎖，對性能影響比較大。所以說當(dāng)消費者數(shù)量小于分區(qū)數(shù)量的時候，我們可以增加消費者的數(shù)量來增加消息處理能力，但當(dāng)消費者數(shù)量大于分區(qū)的時候再繼續(xù)增加消費者數(shù)量就沒有意義了。

不能增加Consumer的時候，可以在同一個Consumer中提升處理消息的并行度，即通過多個goroutine來并行的消費數(shù)據(jù)，我們一起來看看如何通過多個goroutine來消費消息。

在Service中定義msgsChan，msgsChan為Slice，Slice的長度表示有多少個goroutine并行的處理數(shù)據(jù)，初始化如下：

func NewService(c config.Config) *Service {
  s := &Service{
    c:          c,
    ProductRPC: product.NewProduct(zrpc.MustNewClient(c.ProductRPC)),
    OrderRPC:   order.NewOrder(zrpc.MustNewClient(c.OrderRPC)),
    msgsChan:   make([]chan *KafkaData, chanCount),
  }
  for i := 0; i < chanCount; i++ {
    ch := make(chan *KafkaData, bufferCount)
    s.msgsChan[i] = ch
    s.waiter.Add(1)
    go s.consume(ch)
  }
  return s
}

從Kafka中消費到數(shù)據(jù)后，把數(shù)據(jù)投遞到Channel中，注意投遞消息的時候按照商品的id做Sharding，這能保證在同一個Consumer中對同一個商品的處理是串行的，串行的數(shù)據(jù)處理不會導(dǎo)致并發(fā)帶來的數(shù)據(jù)競爭問題

func (s *Service) Consume(_ string, value string) error {
  logx.Infof("Consume value: %s\n", value)
  var data []*KafkaData
  if err := json.Unmarshal([]byte(value), &data); err != nil {
    return err
  }
  for _, d := range data {
    s.msgsChan[d.Pid%chanCount] <- d
  }
  return nil
}

我們定義了chanCount個goroutine同時處理數(shù)據(jù)，每個channel的長度定義為bufferCount，并行處理數(shù)據(jù)的方法為consume，如下：

func (s *Service) consume(ch chan *KafkaData) {
  defer s.waiter.Done()
  for {
    m, ok := <-ch
    if !ok {
      log.Fatal("seckill rmq exit")
    }
    fmt.Printf("consume msg: %+v\n", m)
    p, err := s.ProductRPC.Product(context.Background(), &product.ProductItemRequest{ProductId: m.Pid})
    if err != nil {
      logx.Errorf("s.ProductRPC.Product pid: %d error: %v", m.Pid, err)
      return
    }
    if p.Stock <= 0 {
      logx.Errorf("stock is zero pid: %d", m.Pid)
      return
    }
    _, err = s.OrderRPC.CreateOrder(context.Background(), &order.CreateOrderRequest{Uid: m.Uid, Pid: m.Pid})
    if err != nil {
      logx.Errorf("CreateOrder uid: %d pid: %d error: %v", m.Uid, m.Pid, err)
      return
    }
    _, err = s.ProductRPC.UpdateProductStock(context.Background(), &product.UpdateProductStockRequest{ProductId: m.Pid, Num: 1})
    if err != nil {
      logx.Errorf("UpdateProductStock uid: %d pid: %d error: %v", m.Uid, m.Pid, err)
    }
  }
}

怎么保證不會超賣

當(dāng)秒殺活動開始后，大量用戶點擊商品詳情頁上的秒殺按鈕，會產(chǎn)生大量的并發(fā)請求查詢庫存，一旦某個請求查詢到有庫存，緊接著系統(tǒng)就會進(jìn)行庫存的扣減。然后，系統(tǒng)生成實際的訂單，并進(jìn)行后續(xù)的處理。如果請求查不到庫存，就會返回，用戶通常會繼續(xù)點擊秒殺按鈕，繼續(xù)查詢庫存。簡單來說，這個階段的操作就是三個：檢查庫存，庫存扣減、和訂單處理。因為每個秒殺請求都會查詢庫存，而請求只有查到庫存有余量后，后續(xù)的庫存扣減和訂單處理才會被執(zhí)行，所以，這個階段中最大的并發(fā)壓力都在庫存檢查操作上。

為了支撐大量高并發(fā)的庫存檢查請求，我們需要使用Redis單獨保存庫存量。那么，庫存扣減和訂單處理是否都可以交給Mysql來處理呢？其實，訂單的處理是可以在數(shù)據(jù)庫中執(zhí)行的，但庫存扣減操作不能交給Mysql直接處理。因為到了實際的訂單處理環(huán)節(jié)，請求的壓力已經(jīng)不大了，數(shù)據(jù)庫完全可以支撐這些訂單處理請求。那為什么庫存扣減不能直接在數(shù)據(jù)庫中執(zhí)行呢？這是因為，一旦請求查到有庫存，就意味著該請求獲得購買資格，緊接著就會進(jìn)行下單操作，同時庫存量會減一，這個時候如果直接操作數(shù)據(jù)庫來扣減庫存可能就會導(dǎo)致超賣問題。

直接操作數(shù)據(jù)庫扣減庫存為什么會導(dǎo)致超賣呢？由于數(shù)據(jù)庫的處理速度較慢，不能及時更新庫存余量，這就會導(dǎo)致大量的查詢庫存的請求讀取到舊的庫存值，并進(jìn)行下單，此時就會出現(xiàn)下單數(shù)量大于實際的庫存量，導(dǎo)致超賣。所以，就需要直接在Redis中進(jìn)行庫存扣減，具體的操作是，當(dāng)庫存檢查完后，一旦庫存有余量，我們就立即在Redis中扣減庫存，同時，為了避免請求查詢到舊的庫存值，庫存檢查和庫存扣減這兩個操作需要保證原子性。

我們使用Redis的Hash來存儲庫存，total為總庫存，seckill為已秒殺的數(shù)量，為了保證查詢庫存和減庫存的原子性，我們使用Lua腳本進(jìn)行原子操作，讓秒殺量小于庫存的時候返回1，表示秒殺成功，否則返回0，表示秒殺失敗，代碼如下：

const (
  luaCheckAndUpdateScript = `
local counts = redis.call("HMGET", KEYS[1], "total", "seckill")
local total = tonumber(counts[1])
local seckill = tonumber(counts[2])
if seckill + 1 <= total then
  redis.call("HINCRBY", KEYS[1], "seckill", 1)
  return 1
end
return 0
`
)
func (l *CheckAndUpdateStockLogic) CheckAndUpdateStock(in *product.CheckAndUpdateStockRequest) (*product.CheckAndUpdateStockResponse, error) {
  val, err := l.svcCtx.BizRedis.EvalCtx(l.ctx, luaCheckAndUpdateScript, []string{stockKey(in.ProductId)})
  if err != nil {
    return nil, err
  }
  if val.(int64) == 0 {
    return nil, status.Errorf(codes.ResourceExhausted, fmt.Sprintf("insufficient stock: %d", in.ProductId))
  }
  return &product.CheckAndUpdateStockResponse{}, nil
}
func stockKey(pid int64) string {
  return fmt.Sprintf("stock:%d", pid)
}

對應(yīng)的seckill-rmq代碼修改如下：

func (s *Service) consume(ch chan *KafkaData) {
  defer s.waiter.Done()
  for {
    m, ok := <-ch
    if !ok {
      log.Fatal("seckill rmq exit")
    }
    fmt.Printf("consume msg: %+v\n", m)
    _, err := s.ProductRPC.CheckAndUpdateStock(context.Background(), &product.CheckAndUpdateStockRequest{ProductId: m.Pid})
    if err != nil {
      logx.Errorf("s.ProductRPC.CheckAndUpdateStock pid: %d error: %v", m.Pid, err)
      return
    }
    _, err = s.OrderRPC.CreateOrder(context.Background(), &order.CreateOrderRequest{Uid: m.Uid, Pid: m.Pid})
    if err != nil {
      logx.Errorf("CreateOrder uid: %d pid: %d error: %v", m.Uid, m.Pid, err)
      return
    }
    _, err = s.ProductRPC.UpdateProductStock(context.Background(), &product.UpdateProductStockRequest{ProductId: m.Pid, Num: 1})
    if err != nil {
      logx.Errorf("UpdateProductStock uid: %d pid: %d error: %v", m.Uid, m.Pid, err)
    }
  }
}

到這里，我們已經(jīng)了解了如何使用原子性的Lua腳本來實現(xiàn)庫存的檢查和扣減。其實要想保證庫存檢查和扣減的原子性，還有另外一種方法，那就是使用分布式鎖。

分布式鎖的實現(xiàn)方式有很多種，可以基于Redis、Etcd等等，用Redis實現(xiàn)分布式鎖的文章比較多，感興趣的可以自行搜索參考。這里給大家簡單介紹下基于Etcd來實現(xiàn)分布式鎖。為了簡化分布式鎖、分布式選舉、分布式事務(wù)的實現(xiàn)，etcd社區(qū)提供了一個名為concurrency的包來幫助我們更簡單、正確的使用分布式鎖。它的實現(xiàn)非常簡單，主要流程如下：

首先通過concurrency.NewSession方法創(chuàng)建Session，本質(zhì)上是創(chuàng)建了一個TTL為10的Lease
得到Session對象后，通過concurrency.NewMutex創(chuàng)建一個mutex對象，包括了Lease、key prefix等信息
然后聽過mutex對象的Lock方法嘗試獲取鎖
最后通過mutex對象的Unlock方法釋放鎖

cli, err := clientv3.New(clientv3.Config{Endpoints: endpoints})
if err != nil {
   log.Fatal(err)
}
defer cli.Close()
session, err := concurrency.NewSession(cli, concurrency.WithTTL(10))
if err != nil {
   log.Fatal(err)
}
defer session.Close()
mux := concurrency.NewMutex(session, "lock")
if err := mux.Lock(context.Background()); err != nil {
   log.Fatal(err)
}
if err := mux.Unlock(context.Background()); err != nil {
   log.Fatal(err)
}

結(jié)束語

本篇文章主要是針對秒殺功能繼續(xù)做了一些優(yōu)化。在Kafka消息的生產(chǎn)端做了批量消息聚合發(fā)送的優(yōu)化，Batch思想在實際生產(chǎn)開發(fā)中使用非常多，希望大家能夠活靈活用，在消息的消費端通過增加并行度來提升吞吐能力，這也是提升性能常用的優(yōu)化手段。最后介紹了可能導(dǎo)致超賣的原因，以及給出了相對應(yīng)的解決方案。同時，介紹了基于Etcd的分布式鎖，在分布式服務(wù)中經(jīng)常出現(xiàn)數(shù)據(jù)競爭的問題，一般可以通過分布式鎖來解決，但分布式鎖的引入勢必會導(dǎo)致性能的下降，所以，還需要結(jié)合實際情況考慮是否需要引入分布式鎖。

代碼倉庫: https://github.com/zhoushuguang/lebron

項目地址 https://github.com/zeromicro/go-zero

以上就是go zero微服務(wù)實戰(zhàn)性能優(yōu)化極致秒殺的詳細(xì)內(nèi)容，更多關(guān)于go zero微服務(wù)秒殺優(yōu)化的資料請關(guān)注腳本之家其它相關(guān)文章！

您可能感興趣的文章: