class Concurrent::ReadWriteLock

def acquire_read_lock
  while true
    c = @Counter.value
    raise ResourceLimitError.new('Too many reader threads') if max_readers?(c)
    # If a writer is waiting when we first queue up, we need to wait
    if waiting_writer?(c)
      @ReadLock.wait_until { !waiting_writer? }
      # after a reader has waited once, they are allowed to "barge" ahead of waiting writers
      # but if a writer is *running*, the reader still needs to wait (naturally)
      while true
        c = @Counter.value
        if running_writer?(c)
          @ReadLock.wait_until { !running_writer? }
        else
          return if @Counter.compare_and_set(c, c+1)
        end
      end
    else
      break if @Counter.compare_and_set(c, c+1)
    end
  end
  true
end

def acquire_write_lock
  while true
    c = @Counter.value
    raise ResourceLimitError.new('Too many writer threads') if max_writers?(c)
    if c == 0 # no readers OR writers running
      # if we successfully swap the RUNNING_WRITER bit on, then we can go ahead
      break if @Counter.compare_and_set(0, RUNNING_WRITER)
    elsif @Counter.compare_and_set(c, c+WAITING_WRITER)
      while true
        # Now we have successfully incremented, so no more readers will be able to increment
        #   (they will wait instead)
        # However, readers OR writers could decrement right here, OR another writer could increment
        @WriteLock.wait_until do
          # So we have to do another check inside the synchronized section
          # If a writer OR reader is running, then go to sleep
          c = @Counter.value
          !running_writer?(c) && !running_readers?(c)
        end
        # We just came out of a wait
        # If we successfully turn the RUNNING_WRITER bit on with an atomic swap,
        # Then we are OK to stop waiting and go ahead
        # Otherwise go back and wait again
        c = @Counter.value
        break if !running_writer?(c) && !running_readers?(c) && @Counter.compare_and_set(c, c+RUNNING_WRITER-WAITING_WRITER)
      end
      break
    end
  end
  true
end

def has_waiters?
  waiting_writer?(@Counter.value)
end

def initialize
  super()
  @Counter   = AtomicFixnum.new(0) # single integer which represents lock state
  @ReadLock  = Synchronization::Lock.new
  @WriteLock = Synchronization::Lock.new
end

def max_readers?(c = @Counter.value)
  (c & MAX_READERS) == MAX_READERS
end

def max_writers?(c = @Counter.value)
  (c & MAX_WRITERS) == MAX_WRITERS
end

def release_read_lock
  while true
    c = @Counter.value
    if @Counter.compare_and_set(c, c-1)
      # If one or more writers were waiting, and we were the last reader, wake a writer up
      if waiting_writer?(c) && running_readers(c) == 1
        @WriteLock.signal
      end
      break
    end
  end
  true
end

def release_write_lock
  return true unless running_writer?
  c = @Counter.update { |counter| counter - RUNNING_WRITER }
  @ReadLock.broadcast
  @WriteLock.signal if waiting_writers(c) > 0
  true
end

def running_readers(c = @Counter.value)
  c & MAX_READERS
end

def running_readers?(c = @Counter.value)
  (c & MAX_READERS) > 0
end

def running_writer?(c = @Counter.value)
  c >= RUNNING_WRITER
end

def waiting_writer?(c = @Counter.value)
  c >= WAITING_WRITER
end

def waiting_writers(c = @Counter.value)
  (c & MAX_WRITERS) / WAITING_WRITER
end

def with_read_lock
  raise ArgumentError.new('no block given') unless block_given?
  acquire_read_lock
  begin
    yield
  ensure
    release_read_lock
  end
end

def with_write_lock
  raise ArgumentError.new('no block given') unless block_given?
  acquire_write_lock
  begin
    yield
  ensure
    release_write_lock
  end
end

def write_locked?
  @Counter.value >= RUNNING_WRITER
end