Django使用乐观锁并发下单

并发下单问题演示和解决方案

 

 

 解决办法

悲观锁

• 当查询某条记录时，即让数据库为该记录加锁，锁住记录后别人无法操作，使用类似如下语法

select stock from tb_sku where id=1 for update;

SKU.objects.select_for_update().get(id=1)

悲观锁类似于我们在多线程资源竞争时添加的互斥锁，容易出现死锁现象，采用不多。

乐观锁

• 乐观锁并不是真实存在的锁，而是在更新的时候判断此时的库存是否是之前查询出的库存，如果相同，表示没人修改，可以更新库存，否则表示别人抢过资源，不再执行库存更新。类似如下操作

update tb_sku set stock=2 where id=1 and stock=7;

SKU.objects.filter(id=1,stock=7).update(stock=2)

任务队列

• 将下单的逻辑放到任务队列中（如celery），将并行转为串行，所有人排队下单。比如开启只有一个进程的Celery，一个订单一个订单的处理。

使用乐观锁并发下单

class OrderCommitView(View):
    """订单提交"""

    def post(self,request):
        保存订单信息和订单商品信息"""
        # 获取当前保存订单时需要的信息
        ......


         显式的开启一个事务
        with transaction.atomic():
             创建事务保存点
            save_id = transaction.savepoint()

             保存订单基本信息 OrderInfo（一）
            order = OrderInfo.objects.create(
                order_id=order_id,user=user,address=address,total_count=0,total_amount=Decimal('0'),freight=Decimal(10.00pay_method,status=OrderInfo.ORDER_STATUS_ENUM[UNPAID'] if pay_method == OrderInfo.PAY_METHODS_ENUM[ALIPAYelse
                OrderInfo.ORDER_STATUS_ENUM[UNSEND]
            )

             从redis读取购物车中被勾选的商品信息
            redis_conn = get_redis_connection(carts)
            redis_cart = redis_conn.hgetall(carts_%s' % user.id)
            selected = redis_conn.smembers(selected_%s user.id)
            carts = {}
            for sku_id in selected:
                carts[int(sku_id)] = int(redis_cart[sku_id])
            sku_ids = carts.keys()

             遍历购物车中被勾选的商品信息
             sku_ids:
                 增加的代码: 增加一个死循环
                while True:
                     查询SKU信息
                    sku = SKU.objects.get(id=sku_id)

                     增加的代码: 读取原始库存
                    origin_stock = sku.stock
                    origin_sales = sku.sales

                     判断SKU库存
                    sku_count = carts[sku.id]
                    if sku_count > sku.stock:
                         事务回滚
                        transaction.savepoint_rollback(save_id)
                        return http.JsonResponse({
                                code': 400,errmsg': 库存不足})

                     模拟延迟
                     import time
                     time.sleep(5)

                     SKU减少库存，增加销量
                     sku.stock -= sku_count
                     sku.sales += sku_count
                     sku.save()

                     增加的代码: 乐观锁更新库存和销量
                     计算差值
                    new_stock = origin_stock - sku_count
                    new_sales = origin_sales + sku_count
                    result = SKU.objects.filter(
                                    id=sku_id,stock=origin_stock
                    ).update(stock=new_stock,sales=new_sales)
                     如果下单失败，但是库存足够时，
                     继续下单，直到下单成功或者库存不足为止
                    if result == 0:
                        continue

                     修改SPU销量
                    sku.goods.sales += sku_count
                    sku.goods.save()

                     保存订单商品信息 OrderGoods（多）
                    OrderGoods.objects.create(
                        order=order,sku=sku,count=sku_count,price=sku.price,)

                     保存商品订单中总价和总数量
                    order.total_count += sku_count
                    order.total_amount += (sku_count * sku.price)

                     增加的代码: 
                     下单成功或者失败就跳出循环
                    break

                 添加邮费和保存订单信息
                order.total_amount += order.freight
                order.save()
             清除保存点
            transaction.savepoint_commit(save_id)

         清除购物车中已结算的商品
        pl = redis_conn.pipeline()
        pl.hdel(' % user.id,*selected)
        pl.srem(selected)
        pl.execute()

         响应提交订单结果
        return http.JsonResponse({: 0,1)">下单成功order_id: order.order_id
                                 })