3

Tastypie 文档指出，捆绑包使 Tastypie 更加线程安全，但没有解释如何以及在什么条件下。我已经查看了代码，但是没有足够的经验来解决它。

我正在制作一个游戏原型，它有一个圆形对象（对于每一轮比赛）和每一轮的多个状态（对于该轮每个玩家的信息）。每个玩家都会通过对回合单词短语的回答来更新自己的状态。我需要一种机制来懒惰地创建下一轮游戏，如果它还不存在的话。我目前在玩家更新他们的状态时触发该轮创建。

如果多个玩家同时更新他们的状态（见StateResource.obj_update()），那么他们创建下一轮的尝试会发生冲突吗？我认为如果一个obj_update调用检查下一轮是否存在并尝试在另一个obj_update完成创建下一轮之前创建下一轮，则可能会发生这种情况。我会用某种类型的互斥锁来解决这个问题，但我不确定这是否有必要。我想知道是否有一种美味的方式来解决这个问题。

我的代码如下：

#models.py
class Round(models.Model):
    game_uid = models.CharField(max_length=75)
    word = models.CharField(max_length=75)
    players = models.ManyToManyField(User)
    next_round = models.OneToOneField('self',null=True,blank=True)

class PlayerRoundState(models.Model):
    player = models.ForeignKey(User)
    round = models.ForeignKey(Round)
    answer = models.CharField(max_length=75)

#api.py
class RoundResource(ModelResource):
    players = fields.ManyToManyField(UserResource, attribute='players',full=False)
    states = fields.ManyToManyField('wordgame.api.StateResource',
                                attribute='playerroundstate_set',
                                full=True)
    . . .
    def obj_create(self, bundle, request=None, **kwargs):
        bundle = super(RoundResource, self).obj_create(bundle, request,**kwargs)
        bundle.obj.word = choice(words) #Gets a random word from a list
        bundle.obj.round_number = 1
        bundle.obj.game_uid = bundle.obj.calc_guid() #Creates a unique ID for the game
        bundle.obj.save()
        return bundle

class StateResource(ModelResource):
    player = fields.ForeignKey(UserResource, 'player',full=False)
    round = fields.ForeignKey(RoundResource, 'round')
    . . . 
    def obj_update(self, bundle, request=None, skip_errors=False, **kwargs):
        bundle = super(StateResource, self).obj_update(bundle, request,
                                                   skip_errors, **kwargs)
        if bundle.obj.round.next_round is None:
            new_round = Round()
            new_round.word = choice(words)
            new_round.round_number = bundle.obj.round.round_number + 1
            new_round.game_uid = bundle.obj.round.game_uid
            new_round.save()
            for p in bundle.obj.round.players.all():
                new_round.players.add(p)
            new_round.save()
            bundle.obj.round.next_round = new_round
            bundle.obj.round.save()

        return bundle
4

1 回答 1

0

我认为这与 Tastypie 没有太大关系。

您描述的问题与 ORM 和数据库有关。问题是，在某些情况下，这两个请求都可能创建新请求Round()（如果它们可以并行服务并随时切换，gunicorn 和 gevent 就是这种情况），并且其中一个请求会变得陈旧。

考虑以下情况：

第一个请求到达，检索当前轮并“看到”没有“下一个”轮。所以它执行：

new_round = Round()
new_round.word = choice(words)
new_round.round_number = bundle.obj.round.round_number + 1
new_round.game_uid = bundle.obj.round.game_uid
new_round.save()

与此同时，第二个请求来了，并且（假设它在您的设置中是可能的）处理切换到第二个请求。它还检索当前回合，并且它还“看到”没有下一轮，因此它也创建了一个（同一逻辑回合的第二个对象）。

然后处理切换回执行的第一个请求：

for p in bundle.obj.round.players.all():
    new_round.players.add(p)
new_round.save()
bundle.obj.round.next_round = new_round
bundle.obj.round.save()

所以现在“有”下一轮。第一个请求已处理，一切看起来都不错。但是第二个请求还没有完成，它执行了同样的操作，覆盖了当前的轮对象。

结果是您有一个过时的实例（Round由第一个请求创建），并且第一组玩家使用Round与第二组不同的实例。

这会导致数据库中的状态不一致。因此，在这种情况下，您的资源更新方法不是线程安全的。

对此的一种解决方案是select_for_update用于从数据库中检索当前轮次。请参阅Django 文档。如果你使用它，第二个和连续的请求将等到你在第一个请求中修改当前轮次，然后才从数据库中检索它。结果将是他们已经“看到”了下一轮，而不是尝试创建它。当然，您必须确保整个更新构成一个事务。

“使用”它的obj_get()方法是覆盖资源中的方法，StateResource而不是：

base_object_list = self.get_object_list(request).filter(**kwargs)

使用（未测试）：

base_object_list = self.get_object_list(request).select_for_update().filter(**kwargs)

当然，这不是唯一的解决方案，但其他解决方案可能会涉及重新设计您的应用程序，因此这可能会涉及较少。

于 2012-09-05T02:21:06.713 回答