持续创作，加速成长！这是我参与「掘金日新计划 · 6 月更文挑战」的第20天，点击查看活动详情

写在前面

这是一篇关于Go语言实现商城秒杀的解决方案。其实商城的秒杀就是高并发问题，那高并发下我们主要解决的就是数据竞争问题

当两个或多个协程同时访问同一个内存地址，并且至少有一个是在写时，就会发生数据竞争。比如A线程修改完之后，线程B读的是线程A之前的值(初始值)，所以不知道A是否修改，所以会导致线程B也把自己修改的值放到这个内存地址中，就会导致本次修改无意义。

在这里插入图片描述常用的方法就是加锁了，当这个进程已经执行了，就为该进程进行加锁，防止其他进程对这个数据进行修改，所以这个数据进行修改之后，再释放这个锁。

关于加锁，我们有两种锁机制，悲观锁和乐观锁。

悲观锁，就是什么时候都保持悲观状态，认为任何地点都会发生这种情况，所以都会加上一个锁，锁住这段逻辑代码。
乐观锁，就是什么时候都保持乐观状态，认为只有在修改的时候会发生问题，所以并不是一个真正意义上的锁，而是一个版本的管理，保持一个数据的多版本，出现错误就进行回滚，类似MySQL的MVCC机制。

1. 场景说明

1.1 场景描述

本次秒杀商城，我们对数据库商品数量进行操作。

秒杀的商品在这里插入图片描述秒杀成功的名单

1.2 事务编写

初始化本次秒杀的商品

func InitializerSecKill(gid int) {
	tx := model.DB.Begin()            // 开启事务
	err := model.DeleteByGoodsId(gid) 
	// 删除前一次秒杀的所有用户，既删除表 success_killed
	if err != nil { 		// 发生错误的话就进行回滚
		tx.Rollback()
	}
	err = model.UpdateCountByGoodsId(gid) 
	// 更新商品的信息表 promotion_sec_kill
	if err != nil {
		tx.Rollback()
	}
	tx.Commit()
}

开启50个线程并发进行秒杀

func WithoutLockSecKill(gid int) serializer.Response {
	code := e.SUCCESS
	seckillNum := 50
	wg.Add(seckillNum)
	InitializerSecKill(gid)
	for i := 0; i < seckillNum; i++ {
		userID := i
		go func() {
			err := WithoutLockSecKillGoods(gid, userID)
			if err != nil {
				fmt.Println("Error",err)
			} else {
				fmt.Printf("User: %d seckill successfully.\n", userID)
			}
			wg.Done()
		}()
	}
	wg.Wait()
	killedCount, err := GetKilledCount(gid)
	if err != nil {
		code = e.ERROR
		logging.Error("Seckill System Error")
		return serializer.Response{
			Status: code,
			Msg:    e.GetMsg(code),
			Error:  err.Error(),
		}
	}
	fmt.Println(killedCount)
	logging.Infof("kill %v product", killedCount)
	return serializer.Response{
		Status: code,
		Msg:    e.GetMsg(code),
	}
}

2. 单机模式

2.1 不加锁出现超卖情况

api/v1/without-lock?gid=1197

func WithoutLockSecKillGoods(gid, userID int) error {
	tx := model.DB.Begin()
	// 检查库存
	count, err := model.SelectCountByGoodsId(gid)
	if err != nil {
		return err
	}
	if count > 0 {
		// 1. 扣库存
		err = model.ReduceStockByGoodsId(gid, int(count-1))
		if err != nil {
			tx.Rollback()
			return err
		}
		// 2. 创建订单
		kill := model.SuccessKilled{
			GoodsId:    int64(gid),
			UserId:     int64(userID),
			State:      0,
			CreateTime: time.Now(),
		}
		err = model.CreateOrder(kill)
		if err != nil {
			tx.Rollback()
			return err
		}
	}
	tx.Commit()
	return nil
}

2.2 加锁(sync包中的Mutex类型的互斥锁),没有问题

api/v1/with-lock?gid=1197

func WithLockSecKillGoods(gid,userID int) error {
	lock.Lock()
	err := WithoutLockSecKillGoods(gid, userID)
	lock.Unlock()
	return err
}

2.3 加锁(数据库悲观锁，读限定), 出现超卖

api/v1/with-pcc-read?gid=1197

func SelectCountByGoodsIdPcc(gid int) (int64, error) {
	skGood:=PromotionSecKill{}
	err := DB.Model(PromotionSecKill{}).Set("gorm:query_option", "FOR UPDATE").
		Where("goods_id=?",gid).First(&skGood).Error
	return skGood.PsCount, err
}

加入FOR UPDATE进行读锁。

2.4 加锁(数据库悲观锁，更新限定), 正常

api/v1/with-pcc-update?gid=1197

func ReduceByGoodsId(gid int) (int64, error) {
	var count int64
	sqlStr := `UPDATE promotion_sec_kill SET ps_count = ps_count-1 WHERE ps_count>0 AND goods_id = ?`
	res := DB.Exec(sqlStr, gid)
	if err := res.Error; err != nil {
		return count, err
	}
	count = res.RowsAffected
	return count, nil
}

ps_count>0 进行限定作用。

2.5 加锁(数据库乐观锁，正常)

api/v1/with-occ?gid=1197

func ReduceStockByOcc(gid int, num int, version int) (int64, error) {
	var count int64
	sqlStr := "UPDATE promotion_sec_kill SET ps_count = ps_count-?, version = version+1 " +
		"WHERE version = ? AND goods_id = ?"
	res := DB.Exec(sqlStr, num, version, gid)
	if err := res.Error; err != nil {
		return count, err
	}
	count = res.RowsAffected
	return count, nil
}

使用version进行版本的控制，从而实现乐观锁。

2.6 使用 channel 限制，正常

api/v1/with-channel?gid=1197

func ChannelConsumer() {
	for {
		kill, ok := <-(*GetInstance())
		if !ok {
			continue
		}
		err := WithoutLockSecKillGoods(kill[0], kill[1])
		if err != nil {
			logging.Error("Error")
		} else {
			logging.Infof("User:%v SecKill Successfully", kill[1])
		}
	}
}

将每个商品id和用户id放入其中，然后可以把channel作为一把锁，起到了阻塞作用。

商品秒杀的本质以及Golang实现解决方案（单机版）