To do this you need a shared lock for the readers, and for the writer to
gain an exclusive lock at the point where it wants to swap the data. While
any shared locks are held, the exclusive lock will not be granted; and while
an exclusive lock is held no shared or exclusive locks will be granted.

Have a look at sync.rb in the standard Ruby distribution, although I've not
used it in anger myself. Something like this might do the trick:

require 'sync'

class DatabaseServer

  def initialize
    @sync = Sync.new
    @data = {}
  end

  def search(k)
    @sync.synchronize(Sync::SH) {
      puts "Reading..."
      sleep 1
      puts "Read done"
      @data[k]
    }
  end

  def update(k,v)
    @sync.synchronize(Sync::EX) {
      puts "Updating..."
      @data[k] = v
      sleep 2
      puts "Update done"
    }
  end
end

d = DatabaseServer.new

t1 = Thread.new {
  sleep 0.5
  d.update("foo","bar")

Note that this is an artificial example, since reading an element from a
hash or writing an element to a hash are 'atomic' operations as far as the
Ruby thread scheduler is concerned. That is, in this simplistic case,
everything will work fine without explicit synchronisation. But as soon as
your searches or updates become multi-step operations (e.g. a search
involves a lookup in index I followed by a read of record R) then you need
this, so that for any particular operation, the index and the records are in
a consistent state throughout. The same applies for write-after-read
operations, such as @id=@id+1.

You'll also need to be careful about what you return to your clients. Don't
return a reference to some object which may be mutated later; use 'dup' to
make a copy for the client if necessary.

However, using sleep also helps you simulate race conditions, where thread 1
does X followed by Y, and you want to see what happens if thread 2 does Z in
between X and Y. That's what I'm using it for above. You can use this to
demonstrate that two or more threads can successfully obtain a shared lock
at the same time, for instance.

BTW there's a good introductory chapter in Programming Ruby:
http://www.rubycentral.com/book/tut_threads.html

And you might want to look at 'madeleine', which is an in-RAM object
database written in Ruby.

Regards,