python 如何解决高并发下的库存问题

        一个简单的使用场景:一件商品的库存只有5件,同时A用户买了5个,B用户买了5个,都提交数据,照成库存不足的问题。

        逻辑:根据一般电商商品的模型类,生成订单一般包括订单类(Order)和订单详情类(DetailOrder),这两张表根据外键order_id 进行关联,所以是同生共死的关系,所以我们在这里用事务来控制。那么python如何解决库存问题呢?

        python 提供了2种方法解决该问题的问题:1,悲观锁;2,乐观锁

        悲观锁:在查询商品储存的时候加锁 select_for_update()  在发生事务的commit或者是事务的rollback时,自动释放该锁,这样其他用户就可以接着查询该商品。

        乐观锁:乐观锁不是真正的锁,在创建订单之前查询商品的库存,在创建订单详情表前,update更新查询数据,如果两次查询的库存量一样就创建详情表,并减去库存,否则,循环三次,如果都不一样,就发生rollback。

        使用场景:并发量高的时候使用悲观锁,缺点:加锁消耗资源

                       并发量低的时候使用乐观锁,缺点:乐观锁循环耗费时间。

代码:

悲观锁:

 @transaction.atomic
    def post(self, request):
        “””接受数据  修改购物车数据 添加订单 和订单商品 加悲观锁 解决并发问题”””
        sku_ids = request.POST.get(‘sku_ids’)
        addr_id =request.POST.get(‘addr_id’)
        pay_method = request.POST.get(‘pay_method’)
        transit_price = request.POST.get(‘transit_price’)
        user = request.user
        if not user.is_authenticated():  # 判断是否登陆
            return JsonResponse({‘res’: 0, ‘errmsg’: ‘用户未登录,请先登陆’})
        try:  # 判断地址是否存在
            address = Customer.objects.get(id=addr_id)
        except Customer.DoesNotExist:
            return JsonResponse({‘res’: 1, ‘errmsg’: ‘地址不存在’})

        #  判断支付方式是否存在
        if pay_method not in OrderInfo.PAY_METHODS.keys():
            return JsonResponse({‘res’: 2, ‘errmsg’: ‘支付方式不存在’})
        total_price = 0
        total_count = 0
        order_id = datetime.now().strftime(‘%Y%m%d%H%M%S’) + str(user.id)
        # 设置事务保存点
        tip = transaction.savepoint()
        try:
            new_order =OrderInfo.objects.create(order_id=order_id,
                                     user=user,
                                     addr=address,
                                     pay_method=pay_method,
                                     total_count=total_count,
                                     total_price=total_price,
                                     transit_price=transit_price)
        except Exception as e:
            # 回滚到tip
            transaction.savepoint_rollback(tip)
            return JsonResponse({‘res’: 3, ‘errmsg’: ‘生成订单失败’})
        cart_key = ‘cart_%d’ % user.id
        conn = get_redis_connection(‘default’)
        skus = conn.hgetall(cart_key)
        for sku_id in eval(sku_ids):  # 循环获得商品的信息  每条数据生成一个订单商品数据
            # 获得购物车中每个商品的数量
            sku_count = conn.hget(cart_key, sku_id)
            if not sku_count:  # 判断购物车里有没有该商品
                # 回滚到tip
                transaction.savepoint_rollback(tip)
                return JsonResponse({‘res’: 4, ‘errmsg’: ‘该商品不在购物车中’})
            try:  # 在商品表中 找该商品sel
                sku = GoodsSKU.objects.select_for_update().get(id=sku_id, is_show=1)
            except GoodsSKU.DoesNotExist:
                # 回滚到tip
                transaction.savepoint_rollback(tip)
                return JsonResponse({‘res’: 5, ‘errmsg’: ‘该商品已下架’})
            price = sku.price
            sku_count = int(sku_count)
            if sku_count > int(sku.count):  # 判断库存
                # 回滚到tip
                transaction.savepoint_rollback(tip)
                return JsonResponse({‘res’: 6, ‘errmsg’: ‘库存不足’})
            price = int(price)
            sku_price = sku_count * price
            total_price += sku_price
            total_count += sku_count
            # 添加订单商品表
            try:
                OrderGoods.objects.create(order=new_order,
                                          sku=sku,
                                          count=sku_count,
                                          price=sku_price,
                                          )
            except Exception as e:
                # 回滚到tip
                transaction.savepoint_rollback(tip)
                return JsonResponse({‘res’: 7, ‘errmsg’: ‘订单商品创建失败’})
            # 减少商品库存 增加商品销售额
            sku.count -= sku_count
            sku.sale_count += sku_count
            sku.save()
            # 删除修改购物车数据
            conn.hdel(cart_key, sku_id)
        total_price += int(transit_price)
        # 修改order 订单数量 总价  邮费
        new_order.total_count = total_count
        new_order.total_price = total_price
        new_order.transit_price = transit_price
        new_order.save()
        #释放保存点

        transaction.savepoint_commit(tip)

乐观锁:

          @transaction.atomic
    def post(self, request):
        ”’订单创建”’
        # 判断用户是否登录
        user = request.user
        if not user.is_authenticated():
            return JsonResponse({‘res’:0, ‘errmsg’:’用户未登录’})
        # 接收参数
        addr_id = request.POST.get(‘addr_id’)
        pay_method = request.POST.get(‘pay_method’)
        sku_ids = request.POST.get(‘sku_ids’) # 1,4
        # 校验参数
        if not all([addr_id, pay_method, sku_ids]):
            return JsonResponse({‘res’:1, ‘errmsg’:’数据不完整’})
        # 校验地址
        try:
            addr = Address.objects.get(id=addr_id)
        except Address.DoesNotExist:
            # 地址不存在
            return JsonResponse({‘res’:2, ‘errmsg’:’地址信息错误’})
        # 校验支付方式
        if pay_method not in OrderInfo.PAY_METHODS.keys():
            # 支付方式无效
            return JsonResponse({‘res’:3, ‘errmsg’:’支付方式无效’})
        # 业务处理:订单创建
        # 组织参数
        # 订单id(order_id): 20171211123130+用户的id
        order_id = datetime.now().strftime(‘%Y%m%d%H%M%S’)+str(user.id)
        # 运费
        transit_price = 10
        # 总数目和总金额
        total_count = 0
        total_price = 0
        # 设置保存点
        sid = transaction.savepoint()
        try:
            # todo: 向df_order_info表中添加一条记录
            order = OrderInfo.objects.create(order_id=order_id,
                                             user=user,
                                             addr=addr,
                                             pay_method=pay_method,
                                             total_count=total_count,
                                             total_price=total_price,
                                             transit_price=transit_price)
            conn = get_redis_connection(‘default’)
            cart_key = ‘cart_%d’%user.id
            # todo: 用户的订单中包含几个商品,就应该向df_order_goods中添加几条记录
            sku_ids = sku_ids.split(‘,’) # [1,4]
            for sku_id in sku_ids:
                for i in range(3):
                    # 根据sku_id获取商品的信息
                    try:
                        # select * from df_goods_sku where id=sku_id;
                        sku = GoodsSKU.objects.get(id=sku_id)
                    except GoodsSKU.DoesNotExist:
                        transaction.savepoint_rollback(sid)
                        return JsonResponse({‘res’:4, ‘errmsg’:’商品信息错误’})
                    # 获取用户要购买的商品的数目
                    count = conn.hget(cart_key, sku_id)
                    # todo: 判断商品库存
                    if int(count) > sku.stock:
                        transaction.savepoint_rollback(sid)
                        return JsonResponse({‘res’:6, ‘errmsg’:’商品库存不足’})
                    # todo: 减少商品的库存,增加销量
                    origin_stock = sku.stock
                    new_stock = origin_stock – int(count)
                    new_sales = sku.sales + int(count)
                    # print(‘user:%d i:%d stock:%d’%(user.id, i, origin_stock))
                    # import time
                    # time.sleep(10)
                    # 返回更新的行数
                    # update df_goods_sku set stock=new_stock, sales=new_sales
                    # where id=sku_id and stock=origin_stock
                    res = GoodsSKU.objects.filter(id=sku_id, stock=origin_stock).update(stock=new_stock, sales=new_sales)
                    if res == 0:
                        # 更新失败
                        if i == 2:
                            # 已经尝试了3次,下单失败
                            transaction.savepoint_rollback(sid)
                            return JsonResponse({‘res’:7, ‘errmsg’:’下单失败2′})
                        continue
                    # todo: 向df_order_goods中添加一条记录
                    OrderGoods.objects.create(order=order,
                                              sku=sku,
                                              count=count,
                                              price=sku.price)
                    # todo: 累加计算商品的总件数和总金额
                    total_count += int(count)
                    total_price += sku.price*int(count)
                    # 更新成功之后跳出循环
                    break
            # todo: 更新order的total_count和total_price
            order.total_count = total_count
            order.total_price = total_price
            order.save()
        except Exception as e:
            transaction.savepoint_rollback(sid)
            return JsonResponse({‘res’:7, ‘errmsg’:’下单失败’})
        # 释放保存点
        transaction.savepoint_commit(sid)
        # todo: 删除购物车对应记录信息
        conn.hdel(cart_key, *sku_ids) # 1,4
        # 返回应答
        return JsonResponse({‘res’:5, ‘message’:’订单创建成功’})

 tip:使用乐观锁时,记得修改mysql的隔离级别:vi /etc/mysql/mysql.conf.d/mysqld.cnf    在mysqld最下面一行添加:transaction-isolation = READ_COMMITTED 。

    原文作者:huangyali_python
    原文地址: https://blog.csdn.net/huangyali_python/article/details/79511654
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞