ruby-on-rails - 如何确保模型始终使用事务和锁(在 Rails 中)？

Question

我注意到 Rails 可能与多个服务器存在并发问题，并希望强制我的模型始终锁定。这在 Rails 中是否可能，类似于强制数据完整性的唯一约束？还是只需要仔细编程？

一号航站楼

irb(main):033:0* Vote.transaction do
irb(main):034:1* v = Vote.lock.first
irb(main):035:1> v.vote += 1
irb(main):036:1> sleep 60
irb(main):037:1> v.save
irb(main):038:1> end

二号航站楼， sleep 时

irb(main):240:0* Vote.transaction do
irb(main):241:1* v = Vote.first
irb(main):242:1> v.vote += 1
irb(main):243:1> v.save
irb(main):244:1> end

数据库启动

 select * from votes where id = 1;
 id | vote |         created_at         |         updated_at         
----+------+----------------------------+----------------------------
  1 |    0 | 2013-09-30 02:29:28.740377 | 2013-12-28 20:42:58.875973 

执行后

一号航站楼

irb(main):040:0> v.vote
=> 1

二号航站楼

irb(main):245:0> v.vote
=> 1

数据库端

select * from votes where id = 1;
 id | vote |         created_at         |         updated_at         
----+------+----------------------------+----------------------------
  1 |    1 | 2013-09-30 02:29:28.740377 | 2013-12-28 20:44:10.276601 

其他示例

http://rhnh.net/2010/06/30/acts-as-list-will-break-in-production

Answer 1

您是正确的，事务本身并不能防止许多常见的并发场景，增加计数器就是其中之一。没有强制锁定的通用方法，您必须确保在代码中需要的任何地方使用它

对于简单的计数器递增场景，有两种机制可以很好地工作:

行锁定

行锁定将起作用 只要你到处做在您的代码中重要的地方。知道重要的地方可能需要一些经验才能对 :/产生直觉。如果像上面的代码一样，您有两个地方需要资源的并发保护，而您只锁定其中一个，则会出现并发问题。

您想使用 with_lock形式;这做了一个交易和一个 行级锁(表锁显然比行锁的伸缩性差得多，尽管对于行数很少的表没有区别，因为 postgresql(不确定 mysql)无论如何都会使用表锁。这看起来像这样:

    v = Vote.first
    v.with_lock do
      v.vote +=1
      sleep 10
      v.save
    end

with_lock创建一个事务，锁定对象所代表的行，并在一个步骤中重新加载对象属性，从而最大限度地减少代码中出现错误的机会。然而，这并不一定能帮助您解决涉及多个对象交互的并发问题。如果 a) 所有可能的交互都依赖于一个对象，并且您始终锁定该对象，并且 b) 其他对象每个只与该对象的一个​​实例交互，则它可以工作，例如锁定用户行并处理所有属于(可能间接)该用户对象的对象。

可序列化事务

另一种可能性是使用可序列化事务。从 9.1 开始，Postgresql 具有“真正的”可序列化事务。这比锁定行的性能要好得多(尽管在简单的计数器递增用例中不太可能重要)

了解可序列化事务给您带来什么的最好方法是:如果您采用所有 (isolation: :serializable) 的所有可能顺序您的应用程序中的交易，保证您的应用程序运行时发生的事情始终与这些顺序之一对应。对于普通交易，不能保证这是真的。

但是，作为交换，您必须做的是处理事务失败时会发生什么，因为数据库无法保证它是可序列化的。在计数器递增的情况下，我们需要做的就是 retry :

    begin
      Vote.transaction(isolation: :serializable) do
        v = Vote.first
        v.vote += 1
        sleep 10 # this is to simulate concurrency 
        v.save
      end
    rescue ActiveRecord::StatementInvalid => e
      sleep rand/100 # this is NECESSARY in scalable real-world code, 
                     # although the amount of sleep is something you can tune.
      retry
    end

注意重试前的随机 sleep 。这是必要的，因为失败的可序列化事务有一个非平凡的成本，所以如果我们不 sleep ，多个进程争夺相同的资源可能会淹没数据库。在高度并发的应用程序中，您可能需要在每次重试时逐渐增加 sleep 。随机对于避免谐波死锁非常重要——如果所有进程 sleep 相同的时间，它们就可以相互进入节奏，它们都在 sleep 中，系统空闲，然后它们都在尝试锁定同时，系统死锁导致除一个外的所有人再次进入休眠状态。

当需要序列化的事务涉及与数据库以外的并发源交互时，您可能仍然需要使用行级锁来完成您需要的操作。这方面的一个例子是，当状态机转换根据对数据库以外的其他内容(如第三方 API)的查询来确定要转换到的状态时。在这种情况下，您需要在查询第三方 API 时使用状态机锁定表示对象的行。您不能在可序列化事务中嵌套事务，因此您必须使用 object.lock!而不是 with_lock .

另一件要注意的事情是在 transaction(isolation: :serializable) 之外获取的任何对象。应该有 reload在事务内部使用之前调用它们。