rubysl-thread 2.0.3 → 2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a55f798bae750c6f72088c3d3675323adccd2616
-  data.tar.gz: 322ab9989a8977bc3ae9e46e1ffea6df8feba31c
+  metadata.gz: 7040690acee184b06a44732773483676d5a3bb91
+  data.tar.gz: 30fd25c832cba84c74908c0dc7775ce7d50607e7
 SHA512:
-  metadata.gz: 29ae78fbba23d0d51127317417c976ec2e2bfdad470d25d64b082421b395bbe45d9008840e9e84a77381e92c293a37e932dd4a101ac29599b625e5d75d3765cc
-  data.tar.gz: 77c41221f5c8a4d8b99e06421e6e36f2b24efadedaf212ba82ef65e54430b5d639dad3685209763617231933d02045c98e91e10e34671a2fcfa36336b5901783
+  metadata.gz: fc9e49bf1e8dd3b70b6bb6ed838f2cb942dc0080d3a2bf37441cb39454d4a179636d35773adca12b7de061d66130e69268135d23a10e0ff5a3ccc7aae6371535
+  data.tar.gz: 9f162c64d9a1af173f686334d437817fd9590c540752800c46466036d7d2ee8291ba64068acfede4c639f245305c67f7bfcfde651f0ca972702f06e57777e093

data/lib/rubysl/thread/version.rb

@@ -1,5 +1,5 @@
 module RubySL
   module Thread
-    VERSION = "2.0.3"
+    VERSION = "2.1"
   end
 end

data/lib/thread.rb

@@ -1 +1,342 @@
-require "rubysl/thread"
+#
+#		thread.rb - thread support classes
+#			$Date: 2006-12-31 07:02:22 -0800 (Sun, 31 Dec 2006) $
+#			by Yukihiro Matsumoto <matz@netlab.co.jp>
+#
+# Copyright (C) 2001  Yukihiro Matsumoto
+# Copyright (C) 2000  Network Applied Communication Laboratory, Inc.
+# Copyright (C) 2000  Information-technology Promotion Agency, Japan
+#
+
+if $DEBUG
+  Thread.abort_on_exception = true
+end
+
+#
+# ConditionVariable objects augment class Mutex. Using condition variables,
+# it is possible to suspend while in the middle of a critical section until a
+# resource becomes available.
+#
+# Example:
+#
+#   require 'thread'
+#
+#   mutex = Mutex.new
+#   resource = ConditionVariable.new
+#
+#   a = Thread.new {
+#     mutex.synchronize {
+#       # Thread 'a' now needs the resource
+#       resource.wait(mutex)
+#       # 'a' can now have the resource
+#     }
+#   }
+#
+#   b = Thread.new {
+#     mutex.synchronize {
+#       # Thread 'b' has finished using the resource
+#       resource.signal
+#     }
+#   }
+#
+class ConditionVariable
+  #
+  # Creates a new ConditionVariable
+  #
+  def initialize
+    @waiters = []
+  end
+
+  #
+  # Releases the lock held in +mutex+ and waits; reacquires the lock on wakeup.
+  #
+  def wait(mutex, timeout=nil)
+    Rubinius.lock(self)
+
+    begin
+      wchan = Rubinius::Channel.new
+
+      begin
+        mutex.unlock
+        @waiters.push wchan
+        Rubinius.unlock(self)
+        signaled = wchan.receive_timeout timeout
+      ensure
+        mutex.lock
+        Rubinius.lock(self)
+
+        unless signaled or @waiters.delete(wchan)
+          # we timed out, but got signaled afterwards (e.g. while waiting to
+          # acquire @lock), so pass that signal on to the next waiter
+          @waiters.shift << true unless @waiters.empty?
+        end
+      end
+
+      if timeout
+        !!signaled
+      else
+        self
+      end
+    ensure
+      Rubinius.unlock(self)
+    end
+  end
+
+  #
+  # Wakes up the first thread in line waiting for this lock.
+  #
+  def signal
+    Rubinius.lock(self)
+    begin
+      @waiters.shift << true unless @waiters.empty?
+    ensure
+      Rubinius.unlock(self)
+    end
+    self
+  end
+
+  #
+  # Wakes up all threads waiting for this lock.
+  #
+  def broadcast
+    Rubinius.lock(self)
+    begin
+      @waiters.shift << true until @waiters.empty?
+    ensure
+      Rubinius.unlock(self)
+    end
+    self
+  end
+end
+
+#
+# This class provides a way to synchronize communication between threads.
+#
+# Example:
+#
+#   require 'thread'
+#
+#   queue = Queue.new
+#
+#   producer = Thread.new do
+#     5.times do |i|
+#       sleep rand(i) # simulate expense
+#       queue << i
+#       puts "#{i} produced"
+#     end
+#   end
+#
+#   consumer = Thread.new do
+#     5.times do |i|
+#       value = queue.pop
+#       sleep rand(i/2) # simulate expense
+#       puts "consumed #{value}"
+#     end
+#   end
+#
+#   consumer.join
+#
+class Queue
+  #
+  # Creates a new queue.
+  #
+  def initialize
+    @que = []
+    @que.taint		# enable tainted comunication
+    self.taint
+    @waiting = []
+    @waiting.taint
+    @mutex = Mutex.new
+    @resource = ConditionVariable.new
+  end
+
+  #
+  # Pushes +obj+ to the queue.
+  #
+  def push(obj)
+    @mutex.synchronize do
+      @que.push obj
+      @resource.signal
+    end
+  end
+
+  #
+  # Alias of push
+  #
+  alias << push
+
+  #
+  # Alias of push
+  #
+  alias enq push
+
+  #
+  # Retrieves data from the queue.  If the queue is empty, the calling thread is
+  # suspended until data is pushed onto the queue.  If +non_block+ is true, the
+  # thread isn't suspended, and an exception is raised.
+  #
+  def pop(non_block=false)
+    while true
+      @mutex.synchronize do
+        #FIXME: some code in net or somewhere violates encapsulation
+        #and demands that a waiting queue exist for Queue, as a result
+        #we have to do a linear search here to remove the current Thread.
+        @waiting.delete(Thread.current)
+        if @que.empty?
+          raise ThreadError, "queue empty" if non_block
+          @waiting.push Thread.current
+          @resource.wait(@mutex)
+        else
+          retval = @que.shift
+          @resource.signal
+          return retval
+        end
+      end
+    end
+  end
+
+  #
+  # Alias of pop
+  #
+  alias shift pop
+
+  #
+  # Alias of pop
+  #
+  alias deq pop
+
+  #
+  # Returns +true+ if the queue is empty.
+  #
+  def empty?
+    @que.empty?
+  end
+
+  #
+  # Removes all objects from the queue.
+  #
+  def clear
+    @que.clear
+  end
+
+  #
+  # Returns the length of the queue.
+  #
+  def length
+    @que.length
+  end
+
+  #
+  # Alias of length.
+  #
+  alias size length
+
+  #
+  # Returns the number of threads waiting on the queue.
+  #
+  def num_waiting
+    @waiting.size
+  end
+end
+
+#
+# This class represents queues of specified size capacity.  The push operation
+# may be blocked if the capacity is full.
+#
+# See Queue for an example of how a SizedQueue works.
+#
+class SizedQueue < Queue
+  #
+  # Creates a fixed-length queue with a maximum size of +max+.
+  #
+  def initialize(max)
+    raise ArgumentError, "queue size must be positive" unless max > 0
+    @max = max
+    @queue_wait = []
+    @queue_wait.taint		# enable tainted comunication
+    @size_mutex = Mutex.new
+    @sem = ConditionVariable.new
+    super()
+  end
+
+  #
+  # Returns the maximum size of the queue.
+  #
+  def max
+    @max
+  end
+
+  #
+  # Sets the maximum size of the queue.
+  #
+  def max=(max)
+    @size_mutex.synchronize do
+      @max = max
+      @sem.broadcast
+    end
+    max
+  end
+
+  #
+  # Pushes +obj+ to the queue.  If there is no space left in the queue, waits
+  # until space becomes available.
+  #
+  def push(obj)
+    while true
+      @size_mutex.synchronize do
+        @queue_wait.delete(Thread.current)
+        if @que.size >= @max
+          @queue_wait.push Thread.current
+          @sem.wait(@size_mutex)
+        else
+          return super(obj)
+        end
+      end
+    end
+  end
+
+  #
+  # Alias of push
+  #
+  alias << push
+
+  #
+  # Alias of push
+  #
+  alias enq push
+
+  #
+  # Retrieves data from the queue and runs a waiting thread, if any.
+  #
+  def pop(*args)
+    retval = super
+
+    @size_mutex.synchronize do
+      if @que.size < @max
+        @sem.broadcast
+      end
+    end
+
+    return retval
+  end
+
+  #
+  # Alias of pop
+  #
+  alias shift pop
+
+  #
+  # Alias of pop
+  #
+  alias deq pop
+
+  #
+  # Returns the number of threads waiting on the queue.
+  #
+  def num_waiting
+    @waiting.size + @queue_wait.size
+  end
+end
+
+# Documentation comments:
+#  - How do you make RDoc inherit documentation from superclass?

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubysl-thread
 version: !ruby/object:Gem::Version
-  version: 2.0.3
+  version: '2.1'
 platform: ruby
 authors:
 - Brian Shirai
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-21 00:00:00.000000000 Z
+date: 2017-10-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -81,7 +81,6 @@ files:
 - README.md
 - Rakefile
 - lib/rubysl/thread.rb
-- lib/rubysl/thread/thread.rb
 - lib/rubysl/thread/version.rb
 - lib/thread.rb
 - rubysl-thread.gemspec
@@ -106,10 +105,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Support classes for working with threads.
 test_files:
 - spec/exclusive_spec.rb
-has_rdoc: 

data/lib/rubysl/thread/thread.rb

@@ -1,342 +0,0 @@
-#
-#		thread.rb - thread support classes
-#			$Date: 2006-12-31 07:02:22 -0800 (Sun, 31 Dec 2006) $
-#			by Yukihiro Matsumoto <matz@netlab.co.jp>
-#
-# Copyright (C) 2001  Yukihiro Matsumoto
-# Copyright (C) 2000  Network Applied Communication Laboratory, Inc.
-# Copyright (C) 2000  Information-technology Promotion Agency, Japan
-#
-
-if $DEBUG
-  Thread.abort_on_exception = true
-end
-
-#
-# ConditionVariable objects augment class Mutex. Using condition variables,
-# it is possible to suspend while in the middle of a critical section until a
-# resource becomes available.
-#
-# Example:
-#
-#   require 'thread'
-#
-#   mutex = Mutex.new
-#   resource = ConditionVariable.new
-#
-#   a = Thread.new {
-#     mutex.synchronize {
-#       # Thread 'a' now needs the resource
-#       resource.wait(mutex)
-#       # 'a' can now have the resource
-#     }
-#   }
-#
-#   b = Thread.new {
-#     mutex.synchronize {
-#       # Thread 'b' has finished using the resource
-#       resource.signal
-#     }
-#   }
-#
-class ConditionVariable
-  #
-  # Creates a new ConditionVariable
-  #
-  def initialize
-    @waiters = []
-  end
-
-  #
-  # Releases the lock held in +mutex+ and waits; reacquires the lock on wakeup.
-  #
-  def wait(mutex, timeout=nil)
-    Rubinius.lock(self)
-
-    begin
-      wchan = Rubinius::Channel.new
-
-      begin
-        mutex.unlock
-        @waiters.push wchan
-        Rubinius.unlock(self)
-        signaled = wchan.receive_timeout timeout
-      ensure
-        mutex.lock
-        Rubinius.lock(self)
-
-        unless signaled or @waiters.delete(wchan)
-          # we timed out, but got signaled afterwards (e.g. while waiting to
-          # acquire @lock), so pass that signal on to the next waiter
-          @waiters.shift << true unless @waiters.empty?
-        end
-      end
-
-      if timeout
-        !!signaled
-      else
-        self
-      end
-    ensure
-      Rubinius.unlock(self)
-    end
-  end
-
-  #
-  # Wakes up the first thread in line waiting for this lock.
-  #
-  def signal
-    Rubinius.lock(self)
-    begin
-      @waiters.shift << true unless @waiters.empty?
-    ensure
-      Rubinius.unlock(self)
-    end
-    self
-  end
-
-  #
-  # Wakes up all threads waiting for this lock.
-  #
-  def broadcast
-    Rubinius.lock(self)
-    begin
-      @waiters.shift << true until @waiters.empty?
-    ensure
-      Rubinius.unlock(self)
-    end
-    self
-  end
-end
-
-#
-# This class provides a way to synchronize communication between threads.
-#
-# Example:
-#
-#   require 'thread'
-#
-#   queue = Queue.new
-#
-#   producer = Thread.new do
-#     5.times do |i|
-#       sleep rand(i) # simulate expense
-#       queue << i
-#       puts "#{i} produced"
-#     end
-#   end
-#
-#   consumer = Thread.new do
-#     5.times do |i|
-#       value = queue.pop
-#       sleep rand(i/2) # simulate expense
-#       puts "consumed #{value}"
-#     end
-#   end
-#
-#   consumer.join
-#
-class Queue
-  #
-  # Creates a new queue.
-  #
-  def initialize
-    @que = []
-    @que.taint		# enable tainted comunication
-    self.taint
-    @waiting = []
-    @waiting.taint
-    @mutex = Mutex.new
-    @resource = ConditionVariable.new
-  end
-
-  #
-  # Pushes +obj+ to the queue.
-  #
-  def push(obj)
-    @mutex.synchronize do
-      @que.push obj
-      @resource.signal
-    end
-  end
-
-  #
-  # Alias of push
-  #
-  alias << push
-
-  #
-  # Alias of push
-  #
-  alias enq push
-
-  #
-  # Retrieves data from the queue.  If the queue is empty, the calling thread is
-  # suspended until data is pushed onto the queue.  If +non_block+ is true, the
-  # thread isn't suspended, and an exception is raised.
-  #
-  def pop(non_block=false)
-    while true
-      @mutex.synchronize do
-        #FIXME: some code in net or somewhere violates encapsulation
-        #and demands that a waiting queue exist for Queue, as a result
-        #we have to do a linear search here to remove the current Thread.
-        @waiting.delete(Thread.current)
-        if @que.empty?
-          raise ThreadError, "queue empty" if non_block
-          @waiting.push Thread.current
-          @resource.wait(@mutex)
-        else
-          retval = @que.shift
-          @resource.signal
-          return retval
-        end
-      end
-    end
-  end
-
-  #
-  # Alias of pop
-  #
-  alias shift pop
-
-  #
-  # Alias of pop
-  #
-  alias deq pop
-
-  #
-  # Returns +true+ if the queue is empty.
-  #
-  def empty?
-    @que.empty?
-  end
-
-  #
-  # Removes all objects from the queue.
-  #
-  def clear
-    @que.clear
-  end
-
-  #
-  # Returns the length of the queue.
-  #
-  def length
-    @que.length
-  end
-
-  #
-  # Alias of length.
-  #
-  alias size length
-
-  #
-  # Returns the number of threads waiting on the queue.
-  #
-  def num_waiting
-    @waiting.size
-  end
-end
-
-#
-# This class represents queues of specified size capacity.  The push operation
-# may be blocked if the capacity is full.
-#
-# See Queue for an example of how a SizedQueue works.
-#
-class SizedQueue < Queue
-  #
-  # Creates a fixed-length queue with a maximum size of +max+.
-  #
-  def initialize(max)
-    raise ArgumentError, "queue size must be positive" unless max > 0
-    @max = max
-    @queue_wait = []
-    @queue_wait.taint		# enable tainted comunication
-    @size_mutex = Mutex.new
-    @sem = ConditionVariable.new
-    super()
-  end
-
-  #
-  # Returns the maximum size of the queue.
-  #
-  def max
-    @max
-  end
-
-  #
-  # Sets the maximum size of the queue.
-  #
-  def max=(max)
-    @size_mutex.synchronize do
-      @max = max
-      @sem.broadcast
-    end
-    max
-  end
-
-  #
-  # Pushes +obj+ to the queue.  If there is no space left in the queue, waits
-  # until space becomes available.
-  #
-  def push(obj)
-    while true
-      @size_mutex.synchronize do
-        @queue_wait.delete(Thread.current)
-        if @que.size >= @max
-          @queue_wait.push Thread.current
-          @sem.wait(@size_mutex)
-        else
-          return super(obj)
-        end
-      end
-    end
-  end
-
-  #
-  # Alias of push
-  #
-  alias << push
-
-  #
-  # Alias of push
-  #
-  alias enq push
-
-  #
-  # Retrieves data from the queue and runs a waiting thread, if any.
-  #
-  def pop(*args)
-    retval = super
-
-    @size_mutex.synchronize do
-      if @que.size < @max
-        @sem.broadcast
-      end
-    end
-
-    return retval
-  end
-
-  #
-  # Alias of pop
-  #
-  alias shift pop
-
-  #
-  # Alias of pop
-  #
-  alias deq pop
-
-  #
-  # Returns the number of threads waiting on the queue.
-  #
-  def num_waiting
-    @waiting.size + @queue_wait.size
-  end
-end
-
-# Documentation comments:
-#  - How do you make RDoc inherit documentation from superclass?