thread 0.0.1

data/README.md

@@ -0,0 +1,68 @@
+thread - various extensions to the thread stdlib
+================================================
+
+Pool
+====
+All the implementations I looked at were either buggy or wasted CPU resources
+for no apparent reason, for example used a sleep of 0.01 seconds to then check for
+readiness and stuff like this.
+
+This implementation uses standard locking functions to work properly across multiple Ruby
+implementations.
+
+Example
+-------
+
+```ruby
+require 'thread/pool'
+
+pool = Thread::Pool.new(4)
+
+10.times {
+  pool.process {
+    sleep 2
+
+    puts 'lol'
+  }
+}
+
+pool.shutdown
+```
+
+You should get 4 lols every 2 seconds and it should exit after 10 of them.
+
+Channel
+=======
+This implements a channel where you can write messages and receive messages.
+
+Example
+-------
+
+```ruby
+require 'thread/channel'
+
+channel = Thread::Channel.new
+channel.send 'wat'
+channel.receive # => 'wat'
+
+channel = Thread::Channel.new { |o| o.is_a?(Integer) }
+channel.send 'wat' # => ArgumentError: guard mismatch
+
+Thread.new {
+  while num = channel.receive(&:even?)
+    puts 'Aye!'
+  end
+}
+
+Thread.new {
+  while num = channel.receive(&:odd?)
+    puts 'Arrr!'
+  end
+}
+
+loop {
+  channel.send rand(1_000_000_000)
+
+  sleep 0.5
+}
+```

data/lib/thread/channel.rb

@@ -0,0 +1,74 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+require 'thread'
+
+class Thread::Channel
+	def initialize (messages = [], &block)
+		@messages = []
+		@mutex    = Mutex.new
+		@cond     = ConditionVariable.new
+		@check    = block
+
+		messages.each {|o|
+			send o
+		}
+	end
+
+	def send (what)
+		if @check && !@check.call(what)
+			raise ArgumentError, 'guard mismatch'
+		end
+
+		@mutex.synchronize {
+			@messages << what
+			@cond.broadcast
+		}
+
+		self
+	end
+
+	def receive (&block)
+		message = nil
+
+		if block
+			found = false
+
+			until found
+				@mutex.synchronize {
+					if index = @messages.find_index(&block)
+						message = @messages.delete_at(index)
+						found   = true
+					else
+						@cond.wait @mutex
+					end
+				}
+			end
+		else
+			@mutex.synchronize {
+				if @messages.empty?
+					@cond.wait @mutex
+				end
+
+				message = @messages.shift
+			}
+		end
+
+		message
+	end
+
+	def receive! (&block)
+		if block
+			@messages.delete_at(@messages.find_index(&block))
+		else
+			@messages.shift
+		end
+	end
+end

data/lib/thread/pool.rb

@@ -0,0 +1,309 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+require 'thread'
+
+class Thread::Pool
+	class Task
+		Timeout = Class.new(Exception)
+		Asked   = Class.new(Exception)
+
+		attr_reader :pool, :timeout, :exception, :thread, :started_at
+
+		def initialize (pool, *args, &block)
+			@pool      = pool
+			@arguments = args
+			@block     = block
+		end
+
+		def running?;    @running;   end
+		def finished?;   @finished;   end
+		def timeout?;    @timedout;   end
+		def terminated?; @terminated; end
+
+		def execute (thread)
+			return if terminated? || running? || finished?
+
+			@thread     = thread
+			@running    = true
+			@started_at = Time.now
+
+			pool.wake_up_timeout
+
+			begin
+				@block.call(*@arguments)
+			rescue Exception => e
+				if e.is_a? Timeout
+					@timedout = true
+				elsif e.is_a? Asked
+					return
+				else
+					@exception = reason
+				end
+			end
+
+			@running  = false
+			@finished = true
+			@thread   = nil
+		end
+
+		def terminate! (exception = Asked)
+			return if terminated? || finished? || timeout?
+
+			@terminated = true
+
+			return unless running?
+
+			@thread.raise exception
+		end
+
+		def timeout!
+			terminate! Timeout
+		end
+
+		def timeout_after (time)
+			@timeout = time
+
+			pool.timeout_for self, time
+
+			self
+		end
+	end
+
+	attr_reader :min, :max, :spawned
+
+	def initialize (min, max = nil, &block)
+		@min   = min
+		@max   = max || min
+		@block = block
+
+		@cond  = ConditionVariable.new
+		@mutex = Mutex.new
+
+		@todo     = []
+		@workers  = []
+		@timeouts = {}
+
+		@spawned       = 0
+		@waiting       = 0
+		@shutdown      = false
+		@trim_requests = 0
+		@auto_trim     = false
+
+		@mutex.synchronize {
+			min.times {
+				spawn_thread
+			}
+		}
+	end
+
+	def shutdown?; !!@shutdown; end
+
+	def auto_trim?;    @auto_trim;         end
+	def auto_trim!;    @auto_trim = true;  end
+	def no_auto_trim!; @auto_trim = false; end
+
+	def resize (min, max = nil)
+		@min = min
+		@max = max || min
+
+		trim!
+	end
+
+	def backlog
+		@mutex.synchronize {
+			@todo.length
+		}
+	end
+
+	def process (*args, &block)
+		unless block || @block
+			raise ArgumentError, 'you must pass a block'
+		end
+
+		task = Task.new(self, *args, &(block || @block))
+
+		@mutex.synchronize {
+			raise 'unable to add work while shutting down' if shutdown?
+
+			@todo << task
+
+			if @waiting == 0 && @spawned < @max
+				spawn_thread
+			end
+
+			@cond.signal
+		}
+
+		task
+	end
+
+	alias << process
+
+	def trim (force = false)
+		@mutex.synchronize {
+			if (force || @waiting > 0) && @spawned - @trim_requests > @min
+				@trim_requests -= 1
+				@cond.signal
+			end
+		}
+
+		self
+	end
+
+	def trim!
+		trim true
+	end
+
+	def shutdown!
+		@mutex.synchronize {
+			@shutdown = :now
+			@cond.broadcast
+		}
+
+		wake_up_timeout
+
+		self
+	end
+
+	def shutdown
+		@mutex.synchronize {
+			@shutdown = :nicely
+			@cond.broadcast
+		}
+
+		join
+
+		if @timeout
+			@shutdown = :now
+
+			wake_up_timeout
+
+			@timeout.join
+		end
+
+		self
+	end
+
+	def join
+		@workers.first.join until @workers.empty?
+
+		self
+	end
+
+	def timeout_for (task, timeout)
+		unless @timeout
+			spawn_timeout_thread
+		end
+
+		@mutex.synchronize {
+			@timeouts[task] = timeout
+
+			wake_up_timeout
+		}
+	end
+
+	def shutdown_after (timeout)
+		Thread.new {
+			sleep timeout
+
+			shutdown
+		}
+
+		self
+	end
+
+	def wake_up_timeout
+		if @pipes
+			@pipes.last.write_nonblock 'x' rescue nil
+		end
+	end
+
+private
+	def spawn_thread
+		@spawned += 1
+
+		thread = Thread.new {
+			loop do
+				task = @mutex.synchronize {
+					if @todo.empty?
+						while @todo.empty?
+							if @trim_requests > 0
+								@trim_requests -= 1
+
+								break
+							end
+
+							break if shutdown?
+
+							@waiting += 1
+							@cond.wait @mutex
+							@waiting -= 1
+
+							break !shutdown?
+						end or break
+					end
+
+					@todo.shift
+				} or break
+
+				task.execute(thread)
+
+				break if @shutdown == :now
+
+				trim if auto_trim? && @spawned > @min
+			end
+
+			@mutex.synchronize {
+				@spawned -= 1
+				@workers.delete thread
+			}
+		}
+
+		@workers << thread
+
+		thread
+	end
+	
+	def spawn_timeout_thread
+		@pipes   = IO.pipe
+		@timeout = Thread.new {
+			loop do
+				now     = Time.now
+				timeout = @timeouts.map {|task, timeout|
+					next unless task.started_at
+
+					now - task.started_at + task.timeout
+				}.compact.min unless @timeouts.empty?
+
+				readable, = IO.select([@pipes.first], nil, nil, timeout)
+
+				break if @shutdown == :now
+
+				if readable && !readable.empty?
+					readable.first.read_nonblock 1024
+				end
+
+				now = Time.now
+				@timeouts.each {|task, time|
+					next if !task.started_at || task.terminated? || task.finished?
+
+					if now > task.started_at + task.timeout
+						task.timeout!
+					end
+				}
+
+				@timeouts.reject! { |task, _| task.terminated? || task.finished? }
+				
+				break if @shutdown == :now
+			end
+		}
+	end
+end

data/lib/thread/recursive_mutex.rb

@@ -0,0 +1,37 @@
+#--
+#           DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                   Version 2, December 2004
+#
+#           DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#  TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+require 'thread'
+
+class RecursiveMutex < Mutex
+	def initialize
+		@threads = Hash.new { |h, k| h[k] = 0 }
+
+		super
+	end
+
+	def lock
+		@thread[Thread.current] += 1
+
+		if @thread[Thread.current] == 1
+			super
+		end
+	end
+
+	def unlock
+		@thread[Thread.current] -= 1
+
+		if @thread[Thread.current] == 0
+			@thread.delete(Thread.current)
+
+			super
+		end
+	end
+end

data/thread.gemspec

@@ -0,0 +1,14 @@
+Gem::Specification.new {|s|
+	s.name         = 'thread'
+	s.version      = '0.0.1'
+	s.author       = 'meh.'
+	s.email        = 'meh@schizofreni.co'
+	s.homepage     = 'http://github.com/meh/ruby-thread'
+	s.platform     = Gem::Platform::RUBY
+	s.summary      = 'Various extensions to the base thread stdlib.'
+
+	s.files         = `git ls-files`.split("\n")
+	s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+	s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+	s.require_paths = ['lib']
+}

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: thread
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- meh.
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-22 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: meh@schizofreni.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/thread/channel.rb
+- lib/thread/pool.rb
+- lib/thread/recursive_mutex.rb
+- thread.gemspec
+homepage: http://github.com/meh/ruby-thread
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Various extensions to the base thread stdlib.
+test_files: []