How can I lock a set of objects for an operation?

Question

In my rails application, I have some code like this:

def foo
  if object_bar_exists
    raise "can't create bar twice!"
  end

  Bar.create
end

Which could be invoked by two different requests coming into the application server. If this code is run by two requests simultaneously, and they both run the if check at the same time, neither will find the other's bar, and 2 bars will be created.

What's the best way to create a "mutex" for "the collection of bars"? A special purpose mutex table in the DB?

update

I should emphasize that I cannot use a memory mutex here, because the concurrency is across requests/processes and not threads.

Answer 1

The best thing to do is perform your operations in a DB transaction. Because you will probably eventually have multiple applications running and they very possibly won't share memory, you won't be able to create a Mutex lock on the application level, especially if those two application services are running on entirely different physical boxes. Here's how to accomplish the DB transaction:

ActiveRecord::Base.transaction do
  # Transaction code goes here.
end

If you want to ensure a rollback on the DB transaction then you'll have to have validation enabled on the Bar class so that an invalid save request will cause a rollback:

ActiveRecord::Base.transaction do
  bar = Bar.new(params[:bar])
  bar.save!
end

If you already have a bar object in the DB, you can lock that object pessimistically like this:

ActiveRecord::Base.transaction do
  bar = Bar.find(1, :lock => true)
  # perform operations on bar
end

Answer 2

If they all the requests are coming into the same machine, and the same ruby virtual machine, you could use Ruby's built in Mutex class: Mutex Docs.

If there are multiple machines or rvms, you will have to use a database transaction to create / get the Bar object, assuming it's stored in the db somehow.