Question

I have a database full of URLs that I need to test HTTP response time for on a regular basis. I want to have many worker threads combing the database at all times for a URL that hasn’t been tested recently, and if it finds one, test it.

Of course, this could cause multiple threads to snag the same URL from the database. I don’t want this. So, I’m trying to use Mutexes to prevent this from happening. I realize there are other options at the database level (optimistic locking, pessimistic locking), but I’d at least prefer to figure out why this isn’t working.

Take a look at this test code I wrote:

threads = []
mutex = Mutex.new

50.times do |i|
  threads << Thread.new do
    while true do 
      url = nil

      mutex.synchronize do
        url = URL.first(:locked_for_testing => false, :times_tested.lt => 150)
        if url
          url.locked_for_testing = true
          url.save 
        end
      end

      if url
        # simulate testing the url
        sleep 1

        url.times_tested += 1
        url.save

        mutex.synchronize do
          url.locked_for_testing = false
          url.save
        end
      end
    end

    sleep 1
  end
end

threads.each { |t| t.join }

Of course there is no real URL testing here. But what should happen is at the end of the day, each URL should end up with “times_tested” equal to 150, right?

(I’m basically just trying to make sure the mutexes and worker-thread mentality are working)

But each time I run it, a few odd URLs here and there end up with times_tested equal to a much lower number, say, 37, and locked_for_testing frozen on “true”

Now as far as I can tell from my code, if any URL gets locked, it will have to unlock. So I don’t understand how some URLs are ending up “frozen” like that.

There are no exceptions and I’ve tried adding begin/ensure but it didn’t do anything.

Any ideas?

Answer 1

I’d use a Queue, and a master to pull what you want. if you have a single master you control what’s getting accessed. This isn’t perfect but it’s not going to blow up because of concurrency, remember if you aren’t locking the database a mutex doesn’t really help you is something else accesses the db.

code completely untested

require 'thread'
queue = Queue.new
keep_running = true

# trap cntrl_c or something to reset keep_running
master = Thread.new do 
  while keep_running
    # check if we need some work to do
    if queue.size == 0
      urls = URL.all(:times_tested.lt => 150)
      urls.each do |u|
        queue << u.id
      end
      # keep from spinning the queue
      sleep(0.1)
    end
  end
end
workers = []
50.times do
  workers << Thread.new do
    while keep_running
      # get an id
      id = queue.shift
      url = URL.get(id)
      #do something with the url
      url.save
      sleep(0.1)
    end
  end
end
workers.each do |w|
  w.join
end