Fix ReadWriteLock wrong-thread write release and stray read release

`release_write_lock` did not verify ownership, so any thread with a
reference to the lock could clear the `RUNNING_WRITER` bit while the
original writer was still inside its critical section. A second writer
could then acquire and run concurrently, breaking write exclusivity.

`release_read_lock` decremented `@Counter` unconditionally. On a fresh
lock the counter dropped to -1, after which `max_readers?` saw
`-1 & MAX_READERS == MAX_READERS` and blocked all subsequent acquires
with `ResourceLimitError`.

Track the write owner in an `AtomicReference` and raise
`IllegalOperationError` from `release_write_lock` when the calling
thread does not hold it, covering both the wrong-thread and never-held
cases. Raise the same error from `release_read_lock` when no read
lock is currently held, matching how `ReentrantReadWriteLock` already
detects this via its per-thread `@HeldCount`.

Author: joshuay03

lib/concurrent-ruby/concurrent/atomic/read_write_lock.rb

@@ -1,5 +1,6 @@
 require 'thread'
 require 'concurrent/atomic/atomic_fixnum'
+require 'concurrent/atomic/atomic_reference'
 require 'concurrent/errors'
 require 'concurrent/synchronization/object'
 require 'concurrent/synchronization/lock'
@@ -58,7 +59,8 @@ class ReadWriteLock < Synchronization::Object
     # Create a new `ReadWriteLock` in the unlocked state.
     def initialize
       super()
-      @Counter   = AtomicFixnum.new(0) # single integer which represents lock state
+      @Counter   = AtomicFixnum.new(0)      # single integer which represents lock state
+      @Writer    = AtomicReference.new(nil) # the thread currently holding the write lock
       @ReadLock  = Synchronization::Lock.new
       @WriteLock = Synchronization::Lock.new
     end
@@ -137,9 +139,13 @@ def acquire_read_lock
     # Release a previously acquired read lock.
     #
     # @return [Boolean] true if the lock is successfully released
+    #
+    # @raise [Concurrent::IllegalOperationError] if no read lock is currently held.
     def release_read_lock
       while true
         c = @Counter.value
+        raise IllegalOperationError, 'Cannot release a read lock which is not held' if running_readers(c) == 0
+
         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
@@ -187,14 +193,21 @@ def acquire_write_lock
           break
         end
       end
+      @Writer.set(Thread.current)
       true
     end
 
     # Release a previously acquired write lock.
     #
     # @return [Boolean] true if the lock is successfully released
+    #
+    # @raise [Concurrent::IllegalOperationError] if the write lock is not held
+    #   by the current thread.
     def release_write_lock
-      return true unless running_writer?
+      unless @Writer.compare_and_set(Thread.current, nil)
+        raise IllegalOperationError, 'Cannot release a write lock which is not held by the current thread'
+      end
+
       c = @Counter.update { |counter| counter - RUNNING_WRITER }
       @ReadLock.broadcast
       @WriteLock.signal if waiting_writers(c) > 0

spec/concurrent/atomic/read_write_lock_spec.rb

@@ -122,6 +122,7 @@ module Concurrent
 
       it 'acquires the lock' do
         expect(subject).to receive(:acquire_read_lock).with(no_args)
+        allow(subject).to receive(:release_read_lock)
         subject.with_read_lock { nil }
       end
 
@@ -163,6 +164,7 @@ module Concurrent
 
       it 'acquires the lock' do
         expect(subject).to receive(:acquire_write_lock).with(no_args)
+        allow(subject).to receive(:release_write_lock)
         subject.with_write_lock { nil }
       end
 
@@ -333,8 +335,8 @@ module Concurrent
         expect(subject.release_read_lock).to be true
       end
 
-      it 'returns true if the lock was never set' do
-        expect(subject.release_read_lock).to be true
+      it 'raises an exception if the lock was never set' do
+        expect { subject.release_read_lock }.to raise_error(IllegalOperationError)
       end
     end
 
@@ -488,8 +490,22 @@ module Concurrent
         expect(subject.release_write_lock).to be true
       end
 
-      it 'returns true if the lock was never set' do
-        expect(subject.release_write_lock).to be true
+      it 'raises an exception if the lock was never set' do
+        expect { subject.release_write_lock }.to raise_error(IllegalOperationError)
+      end
+
+      it 'raises an exception if called by a thread that did not acquire the write lock' do
+        subject.acquire_write_lock
+        intruder_error = nil
+        Thread.new do
+          begin
+            subject.release_write_lock
+          rescue => e
+            intruder_error = e
+          end
+        end.join
+        expect(intruder_error).to be_a(IllegalOperationError)
+        subject.release_write_lock
       end
     end
   end