4

我有 2 个模型:ProductOrder.

Product有一个用于股票的整数字段,而Order有一个状态和一个外键Product

class Product(models.Model):
    name = models.CharField(max_length=30)
    stock = models.PositiveSmallIntegerField(default=1)

class Order(models.Model):
    product = models.ForeignKey('Product')
    DRAFT = 'DR'; INPROGRESS = 'PR'; ABORTED = 'AB'
    STATUS = ((INPROGRESS, 'In progress'),(ABORTED, 'Aborted'),)
    status = models.CharField(max_length = 2, choices = STATUS, default = DRAFT)

我的目标是让每个新订单的产品库存减少 1 个,并为每个订单取消增加 1 个。为此,我重载了模型的save方法Order(受Django 启发:保存时,如何检查字段是否已更改?):

from django.db.models import F

class Order(models.Model):
    product = models.ForeignKey('Product')
    status = models.CharField(max_length = 2, choices = STATUS, default = DRAFT)

    EXISTING_STATUS = set([INPROGRESS])

    __original_status = None

    def __init__(self, *args, **kwargs):
        super(Order, self).__init__(*args, **kwargs)
        self.__original_status = self.status

    def save(self, *args, **kwargs):
        old_status = self.__original_status
        new_status = self.status
        has_changed_status = old_status != new_status
        if has_changed_status:
            product = self.product
            if not old_status in Order.EXISTING_STATUS and new_status in Order.EXISTING_STATUS:
                product.stock = F('stock') - 1
                product.save(update_fields=['stock'])
            elif old_status in Order.EXISTING_STATUS and not new_status in Order.EXISTING_STATUS:
                product.stock = F('stock') + 1
                product.save(update_fields=['stock'])
        super(Order, self).save(*args, **kwargs)
        self.__original_status = self.status

使用 RestFramework,我创建了 2 个视图,一个用于创建新订单,一个用于取消现有订单。两者都使用简单的序列化程序:

class OrderSimpleSerializer(serializers.ModelSerializer):

    class Meta:
        model = Order
        fields = (
            'id',
            'product',
            'status',
        )
        read_only_fields = (
            'status',
        )

class OrderList(generics.ListCreateAPIView):
    model = Order
    serializer_class = OrderSimpleSerializer

    def pre_save(self, obj):
        super(OrderList,self).pre_save(obj)
        product = obj.product
        if not product.stock > 0:
            raise ConflictWithAnotherRequest("Product is not available anymore.")
        obj.status = Order.INPROGRESS

class OrderAbort(generics.RetrieveUpdateAPIView):
    model = Order
    serializer_class = OrderSimpleSerializer

    def pre_save(self, obj):
        obj.status = Order.ABORTED

以下是访问这两个视图的方法:

from myapp.views import *

urlpatterns = patterns('',
    url(r'^order/$', OrderList.as_view(), name='order-list'),
    url(r'^order/(?P<pk>[0-9]+)/abort/$', OrderAbort.as_view(), name='order-abort'),
)

我正在使用 Django 1.6b4、Python 3.3、Rest Framework 2.7.3 和 PostgreSQL 9.2。

我的问题是并发请求可以增加产品的库存高于原始库存!

这是我用来演示的脚本:

import sys
import urllib.request
import urllib.parse
import json

opener = urllib.request.build_opener(urllib.request.HTTPCookieProcessor)

def create_order():
    url = 'http://127.0.0.1:8000/order/'
    values = {'product':1}
    data  = urllib.parse.urlencode(values).encode('utf-8')
    request = urllib.request.Request(url, data)
    response = opener.open(request)
    return response

def cancel_order(order_id):
    abort_url = 'http://127.0.0.1:8000/order/{}/abort/'.format(order_id)
    values = {'product':1,'_method':'PUT'}
    data  = urllib.parse.urlencode(values).encode('utf-8')
    request = urllib.request.Request(abort_url, data)
    try:
        response = opener.open(request)
    except Exception as e:
        if (e.code != 403):
            print(e)
    else:
        print(response.getcode())

def main():
    response = create_order()
    print(response.getcode())
    data = response.read().decode('utf-8')
    order_id = json.loads(data)['id']
    time.sleep(1)
    for i in range(2):
        p = Process(target=cancel_order, args=[order_id])
        p.start()

if __name__ == '__main__':
    main()

对于库存为 1 的产品,此脚本提供以下输出:

201 # means it creates an order for Product, thus decreasing stock from 1 to 0
200 # means it cancels the order for Product, thus increasing stock from 0 to 1
200 # means it cancels the order for Product, thus increasing stock from 1 to 2 (shouldn't happen)

编辑

我添加了一个示例项目来重现该错误: https ://github.com/ThinkerR/django-concurrency-demo

4

3 回答 3

5

看看django-concurrency它使用乐观并发控制模式处理并发编辑。

于 2013-09-27T23:55:01.837 回答
3

我认为问题不在于自动更新产品计数——Django F()ORM 的表达式应该正确处理。但是,以下组合操作:

  1. 检查订单状态(产品数量需要更新吗?)
  2. 更新产品数量
  3. 更新订单状态(取消)

不是原子操作。对于两个线程 A 和 B(都处理同一订单的取消请求),可能有以下事件序列:

A:检查订单状态:新的是取消,与前一个不同
B:检查订单状态:新是取消,与前一个不同
A:将产品计数从 0 原子
更新到 1 B:将产品计数从 1 原子更新为 2
A:将订单状态更新为已取消
B:将订单状态更新为已取消

您需要执行以下操作之一:

  1. 将整个操作更改为在事务中发生。您没有提到您的数据库或事务模式设置。Django 默认为自动提交模式,其中每个数据库操作都是单独提交的。要更改为事务(可能与 HTTP 请求相关),请参阅 https://docs.djangoproject.com/en/dev/topics/db/transactions/
  2. 创建同步屏障以防止两个线程更新产品计数。您可以通过数据库层上的原子比较和交换操作来做到这一点,但我不确定是否有现成的F或类似的原语可以做到这一点。(主要思想是更改订单和产品数据更新的顺序,以便您首先原子地更新和测试订单状态。)
  3. 使用其他形式的同步机制,使用分布式锁系统(您可以为此使用 Redis 和许多其他系统)。不过,我认为这对于这种情况来说有点矫枉过正。

总结:除非您已经为您的应用程序使用 HTTP 级别的事务,否则请尝试ATOMIC_REQUESTS = True在您的 Django 配置文件 ( settings.py) 中进行设置。

如果您不这样做或不能这样做,请注意替代方法不会为您提供订单-产品对的一致性。试着想想如果 Django 服务器在产品更新和订单更新之间崩溃会发生什么——只有一个会被更新。(这是必须的数据库事务,数据库引擎注意到客户端中止 - 由于网络连接中断 - 并回滚事务。)

于 2013-09-23T12:42:57.333 回答
0

正如您提到的,您对并发请求有竞争条件。要摆脱这种情况,您应该使操作原子化。我要做的是使用 Redis 使订单操作原子化。然后尽可能写回常规数据库。

http://redis.io/

编辑:

经过一些评论,似乎最好的方法是包括select_for_update(wait=True)

于 2013-09-23T11:43:31.660 回答