rwlock 1.0.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YTJjZTUxZTcyYmQyZDEwY2Q3ZDY2MmNjODllMjMyNTM1OTkxYzZhYQ==
+  data.tar.gz: !binary |-
+    OTVlYTlmM2VhOGY0YmU3YTY5ODVjZTlkMjhlY2RhNDE2ZjQ2YTE5Yg==
+SHA512:
+  metadata.gz: !binary |-
+    NTIwODgzMWRiNzgxMWM2MDViZjc2MWMxODhhYjNkNTU2YjA4YWY1MGI0MmY3
+    NDFkMWEwY2I4NWQ4MmRiNjBlZWNlYTAyN2QwNTE3YWY1YzM5ZmE4ZmQ2YmU5
+    ZmZmMmEzNjM5MjI0ZTAzZjM5YjUzMzRjNGJmN2ViM2YwOGFhMjc=
+  data.tar.gz: !binary |-
+    M2I4ZjdkZmVmMjhmNGYxZjEzOTk0NTBlZTBhMzVjNDc1MjhmODJhZWE1ODhm
+    MWFkZGM2OGRlNzY3MTAxYjNhOWM4ODZlODcwN2Y3MTNmNmE5M2E5OTFjN2Zh
+    ZmUxMGY4YTBjYzc0OWI2ODU2MjdkOWRiMjc0YmMyZjM4MzI0NDY=

data/lib/rwlock.rb

@@ -0,0 +1,87 @@
+require 'thread'
+if defined? require_relative
+  require_relative 'rwlock/sized_queue_patch'
+else
+  require File.join(File.expand_path(File.dirname(__FILE__)), "rwlock", "sized_queue_patch")
+end
+
+# This class provides a simple readers-writer lock (RWLock).
+# A RWLock allows multiple "readers" to access a resource simultaneously
+# but "writers" must have exclusive access. In other words, during a "write"
+# only a single thread may have access to the resource.
+#
+# This RWLock prevents writer starvation. While there are no hard guarantees,
+# if a writer requests access it will generally get access as soon as all
+# current readers are finished.
+#
+# When the current writer is finished, waiting readers have first opportunity
+# to grab the lock. This should result in no starvation of either readers nor
+# writers, although access may not be "fair".
+class RWLock
+  # Creates new readers-writers lock.
+  # The `max_size` argument limits how many readers may read simultaneously.
+  # A limit is necessary to prevent writer starvation.
+  def initialize max_size = 10
+    @write_lock = Mutex.new
+    @q = SizedQueue.new(max_size)
+  end
+
+  # Obtains reading lock and executes block, then releases reading lock.
+  # Many calls to RWLock#read_sync may execute in parallel, but wil not
+  # overlap with calls to RWLock#write_sync.
+  #
+  # If the number of readers is currently at the maximum or a write operation
+  # is in progress, this method will wait. When a reading spot is available and
+  # no write operations are occurring, then the block will be executed.
+  #
+  #     rwl = RWLock.new
+  #     a = [1, 2, 3]
+  #
+  #     Thread.new do
+  #       rwl.read_sync do
+  #         puts a[1]
+  #       end
+  #     end
+  def read_sync
+    @q.push true
+    yield
+  ensure
+    @q.pop
+  end
+
+  # Obtains writing lock and executes block, then releases writing lock.
+  # The block will have exclusive access to the lock, with no readers or
+  # other writers allowed to execute at the same time.
+  #
+  # If any readers are executing, the method will wait until the current
+  # readers are finished then the block will be executed.
+  #
+  # If another writer is executing, the method will wait until the current
+  # writer is finished. However, readers have first chance at access after a
+  # write.
+  #
+  #     rwl = RWLock.new
+  #     a = [1, 2, 3]
+  #
+  #     Thread.new do
+  #       rwl.write_sync do
+  #         a[1] += 1
+  #       end
+  #     end
+  def write_sync
+    @write_lock.synchronize do
+      @q.max.times { @q.push true }
+
+      begin
+        yield
+      ensure
+        @q.clear
+      end
+    end
+  end
+
+  # Returns the set maximum number of simultaneous readers.
+  def max
+    @q.max
+  end
+end

data/lib/rwlock/sized_queue_patch.rb

@@ -0,0 +1,29 @@
+if not SizedQueue.instance_methods(false).include? :clear
+  if RUBY_VERSION == "1.9.3" and RUBY_PATCHLEVEL < 545
+    class SizedQueue
+      # Removes all objects from the queue and wakes waiting threads, if any.
+      def clear
+        @mutex.synchronize do
+          @que.clear
+          begin
+            until @queue_wait.empty?
+              @queue_wait.shift.wakeup
+            end
+          rescue ThreadError
+            retry
+          end
+        end
+      end
+    end
+  elsif RUBY_VERSION == "2.0.0"
+    class SizedQueue
+      # Removes all objects from the queue and wakes waiting threads, if any.
+      def clear
+        @mutex.synchronize do
+          @que.clear
+          @enque_cond.signal
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,46 @@
+--- !ruby/object:Gem::Specification
+name: rwlock
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Justin Collins
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-27 00:00:00.000000000 Z
+dependencies: []
+description: Simple thread-level readers-writer lock in pure Ruby. Allows multiple
+  readers to access a resource while writers get exclusive access.
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rwlock.rb
+- lib/rwlock/sized_queue_patch.rb
+homepage: https://github.com/presidentbeef/rwlock
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Simple readers-writer lock.
+test_files: []