Cara menggunakan Go dan Lua untuk menyelesaikan masalah inventori dan penjualan berlebihan dalam jualan kilat Redis

0. Pengenalan

• Bahasa Go menghubungkan go-redis untuk menyambung ke pangkalan data Jika anda masih belum memahami bahagian ini, anda disyorkan untuk mempelajari bahagian pengetahuan ini pertama.

• Selain itu, jualan kilat ini terutamanya menyelesaikan dua masalah, yang pertama ialah masalah terlebih jual, dan satu lagi masalah inventori.

• Tiada halaman khas yang direka untuk mensimulasikan concurrency Kami terus menggunakan gorountine dan kekal selama 10 saat sebelum memanggil permintaan.

• Untuk menangani masalah terlebih jual, cuma perkenalkan jam tangan go-redis dan pemprosesan transaksi [bersamaan dengan penguncian optimistik].

Bagi masalah inventori, ia lebih menyusahkan Anda perlu menggunakan Lua untuk mengedit skrip, tetapi anda tidak perlu memuat turun persekitaran kompilasi Lua pada mesin anda sendiri menyediakan sokongan yang berkaitan. Untuk bahagian ini, jangan panik. mungkin berlaku. Walaupun anda membuat pertimbangan ke atas data sebelum beroperasi.

func MsCode(uuid, prodid string) bool {  
   // 1、对uuid和prodid进行非空判断  
   if uuid == "" || prodid == "" {  
      return false  
   }  
  
   //2、获取连接  
   rdb := DB  
  
   //3、拼接key  
   kcKey := "kc:" + prodid + ":qt"  
   userKey := "sk:" + prodid + ":user"  
  
   //4、获取库存  
   str, err := rdb.Get(ctx, kcKey).Result()  
   if err != nil {  
      fmt.Println(err)  
      fmt.Println("秒杀还未开始.......")  
      return false  
   }  
  
   // 5、判断用户是否重复秒杀操作  
   flag, err := rdb.SIsMember(ctx, userKey, userKey).Result()  
   if err != nil {  
      fmt.Println(err)  
   }  
   if flag {  
      fmt.Println("你已经参加了秒杀，无法再次参加。。。。")  
      return false  
   }  
  
   // 6、判断商品数量，如果库存数量小于1，秒杀结束  
   str, err = rdb.Get(ctx, kcKey).Result()  
   if err != nil {  
      fmt.Println(err)  
   }  
   n, err := strconv.Atoi(str)  
   if err != nil {  
      fmt.Println(err)  
   }  
   if n < 1 {  
      fmt.Println("秒杀结束，请下次再来吧。。。。")  
      return false  
   }  
  
   // 7、秒杀过程  
   // 7.1、库存减1  
   num, err := rdb.Decr(ctx, kcKey).Result()  
   if err != nil {  
      fmt.Println(err)  
   }  
   if num != 0 {  
      // 7.2、添加用户  
      rdb.SAdd(ctx, userKey, uuid)  
   }  
   return true  
}

func main() {
    // 并发的版本
    for i := 0; i < 20; i++ {
        go func() {
            uuid := GenerateUUID()
            prodid := "1023"
            time.Sleep(10 * time.Second)
            MsCode(uuid, prodid)
        }()
    }
    time.Sleep(15 * time.Second)
}

2. Selesaikan terlebih jual

Gunakan jam tangan untuk memantau bahagian kunci adalah seperti berikut. Walau bagaimanapun, keadaan ini akan membawa masalah Walaupun terdapat inventori yang tinggal, akan ada orang yang tidak dapat membelinya.

err = rdb.Watch(ctx, func(tx *redis.Tx) error {  
   n, err := tx.Get(ctx, kcKey).Int()  
   if err != nil && err != redis.Nil {  
      return err  
   }  
   if n <= 0 {  
      return fmt.Errorf("抢购结束了！请下次早点来。。。。")  
   }  
   _, err = tx.TxPipelined(ctx, func(pipeliner redis.Pipeliner) error {  
      err := pipeliner.Decr(ctx, kcKey).Err()  
      if err != nil {  
         return err  
      }  
      err = pipeliner.SAdd(ctx, userKey, uuid).Err()  
      if err != nil {  
         return err  
      }  
      return nil  
   })  
   return err  
}, kcKey)

3. Selesaikan masalah inventori Lua

Lua boleh menyelesaikan masalah ini dengan lebih baik dengan mengendalikan redis. Untuk mengelakkan masalah inventori yang mungkin disebabkan oleh penguncian pesimis dalam Redis, anda harus mempertimbangkan untuk menggunakan penguncian optimistik. Oleh kerana Redis tidak mempunyai sokongan penguncian optimistik terbina dalam, kami perlu menggunakan Lua untuk menulis skrip yang berkaitan. Ia terutamanya mempunyai kelebihan berikut:

Tulis operasi redis yang kompleks atau berbilang langkah sebagai skrip dan serahkannya kepada redis untuk dilaksanakan sekali gus, mengurangkan bilangan sambungan redis berulang. Tingkatkan prestasi.

skrip luan adalah serupa dengan transaksi redis, mempunyai atomicity tertentu, tidak akan dibariskan oleh perintah lain dan boleh melengkapkan beberapa operasi transaksi redis.

• Fungsi skrip Lua redis hanya boleh digunakan dalam versi di atas redis2.6.

• Gunakan skrip lua untuk menghapuskan pengguna dan menyelesaikan masalah terlalu banyak jualan.

• Selepas redis versi 2.6, skrip Lua digunakan untuk menyelesaikan masalah pertikaian, sebenarnya, redis menggunakan ciri utas tunggalnya untuk menyelesaikan masalah serentak berbilang tugas menggunakan baris gilir tugas.

• import (
      "context"
      "fmt"
      "github.com/go-redis/redis/v8"
      "net"
      "time"
  )
  
  func useLua(userid, prodid string) bool {
      //编写脚本 - 检查数值，是否够用，够用再减，否则返回减掉后的结果
      var luaScript = redis.NewScript(`
          local userid=KEYS[1];
          local prodid=KEYS[2];
          local qtKey="sk:"..prodid..":qt";
          local userKey="sk:"..prodid..":user";
          local userExists=redis.call("sismember",userKey,userid);
          if tonumber(userExists)==1 then
           return 2;
          end
          local num=redis.call("get",qtKey);
          if tonumber(num)<=0 then
           return 0;
          else
           redis.call("decr",qtKey);
           redis.call("SAdd",userKey,userid);
          end
          return 1;
      `)
      //执行脚本
      n, err := luaScript.Run(ctx, DB, []string{userid, prodid}).Result()
      if err != nil {
          return false
      }
      switch n {
      case int64(0):
          fmt.Println("抢购结束")
          return false
      case int64(1):
          fmt.Println(userid, "：抢购成功")
          return true
      case int64(2):
          fmt.Println(userid, "：已经抢购了")
          return false
      default:
          fmt.Println("发生未知错误！")
          return false
      }
      return true
  }
  
  func main() {
      // 并发的版本
      for i := 0; i < 20; i++ {
          go func() {
              uuid := GenerateUUID()
              prodid := "1023"
              time.Sleep(10 * time.Second)
              useLua(uuid, prodid)
          }()
      }
      time.Sleep(15 * time.Second)
  }

  Atas ialah kandungan terperinci Cara menggunakan Go dan Lua untuk menyelesaikan masalah inventori dan penjualan berlebihan dalam jualan kilat Redis. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!