seekingalpha_thread 1.0.1

data/lib/thread/process.rb

@@ -0,0 +1,71 @@
+#--
+#            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/channel'
+
+# A process should only interact with the outside through messages, it still
+# uses a thread, but it should make it safer to use than sharing and locks.
+class Thread::Process
+	def self.all
+		@@processes ||= {}
+	end
+
+	def self.register(name, process)
+		all[name] = process
+	end
+
+	def self.unregister(name)
+		all.delete(name)
+	end
+
+	def self.[](name)
+		all[name]
+	end
+
+	# Create a new process executing the block.
+	def initialize(&block)
+		@channel = Thread::Channel.new
+
+		Thread.new {
+			instance_eval(&block)
+
+			@channel = nil
+		}
+	end
+
+	# Send a message to the process.
+	def send(what)
+		unless @channel
+			raise RuntimeError, 'the process has terminated'
+		end
+
+		@channel.send(what)
+
+		self
+	end
+
+	alias << send
+
+private
+	def receive
+		@channel.receive
+	end
+
+	def receive!
+		@channel.receive!
+	end
+end
+
+class Thread
+	# Helper to create a process.
+	def self.process(&block)
+		Thread::Process.new(&block)
+	end
+end

data/lib/thread/promise.rb

@@ -0,0 +1,83 @@
+#--
+#            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'
+
+# A promise is an object that lets you wait for a value to be delivered to it.
+class Thread::Promise
+	# Create a promise.
+	def initialize
+		@mutex = Mutex.new
+	end
+
+	# Check if a value has been delivered.
+	def delivered?
+		@mutex.synchronize {
+			instance_variable_defined? :@value
+		}
+	end
+
+	alias realized? delivered?
+
+	# Deliver a value.
+	def deliver(value)
+		return self if delivered?
+
+		@mutex.synchronize {
+			@value = value
+
+			cond.broadcast if cond?
+		}
+
+		self
+	end
+
+	alias << deliver
+
+	# Get the value that's been delivered, if none has been delivered yet the call
+	# will block until one is delivered.
+	#
+	# An optional timeout can be passed which will return nil if nothing has been
+	# delivered.
+	def value(timeout = nil)
+		return @value if delivered?
+
+		@mutex.synchronize {
+			cond.wait(@mutex, *timeout)
+		}
+
+		return @value if delivered?
+	end
+
+	alias ~ value
+
+private
+	def cond?
+		instance_variable_defined? :@cond
+	end
+
+	def cond
+		@cond ||= ConditionVariable.new
+	end
+end
+
+class Thread
+	# Helper method to create a promise.
+	def self.promise
+		Thread::Promise.new
+	end
+end
+
+module Kernel
+	# Helper method to create a promise.
+	def promise
+		Thread::Promise.new
+	end
+end

data/lib/thread/recursive_mutex.rb

@@ -0,0 +1,38 @@
+#--
+#           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'
+
+# A recursive mutex lets you lock in various threads recursively, allowing
+# you to do multiple locks one inside another.
+#
+# You really shouldn't use this, but in some cases it makes your life easier.
+class RecursiveMutex < Mutex
+	def initialize
+		@threads_lock = Mutex.new
+		@threads = Hash.new { |h, k| h[k] = 0 }
+
+		super
+	end
+
+	# Lock the mutex.
+	def lock
+		super if @threads_lock.synchronize{ (@threads[Thread.current] += 1) == 1 }
+	end
+
+	# Unlock the mutex.
+	def unlock
+		if @threads_lock.synchronize{ (@threads[Thread.current] -= 1) == 0 }
+			@threads.delete(Thread.current)
+
+			super
+		end
+	end
+end

data/spec/thread/channel_spec.rb

@@ -0,0 +1,39 @@
+require 'thread/channel'
+
+describe Thread::Channel do
+	it 'receives in the proper order' do
+		ch = Thread.channel
+		ch.send 'lol'
+		ch.send 'wut'
+
+		expect(ch.receive).to eq('lol')
+		expect(ch.receive).to eq('wut')
+	end
+
+	it 'receives with constraints properly' do
+		ch = Thread.channel
+		ch.send 'lol'
+		ch.send 'wut'
+
+		expect(ch.receive { |v| v == 'wut' }).to eq('wut')
+		expect(ch.receive).to eq('lol')
+	end
+
+	it 'receives nil when using non blocking mode and the channel is empty' do
+		ch = Thread.channel
+
+		expect(ch.receive!).to be_nil
+	end
+
+	it 'guards sending properly' do
+		ch = Thread.channel { |v| v.is_a? Integer }
+
+		expect {
+			ch.send 23
+		}.to_not raise_error
+
+		expect {
+			ch.send 'lol'
+		}.to raise_error
+	end
+end

data/spec/thread/delay_spec.rb

@@ -0,0 +1,11 @@
+require 'thread/delay'
+
+describe Thread::Delay do
+	it 'delivers a value properly' do
+		d = Thread.delay {
+			42
+		}
+
+		expect(d.value).to eq(42)
+	end
+end

data/spec/thread/every_spec.rb

@@ -0,0 +1,9 @@
+require 'thread/every'
+
+describe Thread::Every do
+	it 'delivers a value properly' do
+		e = Thread.every(5) { sleep 0.02; 42 }
+
+		expect(e.value).to eq(42)
+	end
+end

data/spec/thread/future_spec.rb

@@ -0,0 +1,34 @@
+require 'thread/future'
+
+describe Thread::Future do
+	it 'delivers a value properly' do
+		f = Thread.future {
+			sleep 0.02
+			42
+		}
+
+		expect(f.value).to eq(42)
+	end
+
+	it 'properly checks if anything has been delivered' do
+		f = Thread.future {
+			sleep 0.02
+
+			42
+		}
+
+		expect(f.delivered?).to eq(false)
+		sleep 0.03
+		expect(f.delivered?).to eq(true)
+	end
+
+	it 'does not block when a timeout is passed' do
+		f = Thread.future {
+			sleep 0.02
+
+			42
+		}
+
+		expect(f.value(0)).to be_nil
+	end
+end

data/spec/thread/pipe_spec.rb

@@ -0,0 +1,23 @@
+require 'thread/pipe'
+
+describe Thread::Pipe do
+	it 'handles passing properly' do
+		p = Thread |-> d { d * 2 } |-> d { d * 4 }
+
+		p << 2
+		p << 4
+
+		expect(p.deq).to eq(16)
+		expect(p.deq).to eq(32)
+	end
+
+	it 'empty works properly' do
+		p = Thread |-> d { sleep 0.02; d * 2 } |-> d { d * 4 }
+
+		expect(p.empty?).to be(true)
+		p.enq 42
+		expect(p.empty?).to be(false)
+		p.deq
+		expect(p.empty?).to be(true)
+	end
+end

data/spec/thread/pool_spec.rb

@@ -0,0 +1,86 @@
+require 'thread/pool'
+
+describe Thread::Pool do
+	it 'creates a new pool with the given amount of threads' do
+		pool = Thread.pool(4)
+
+		expect(pool.spawned).to eq(4)
+
+		pool.shutdown
+	end
+
+	it 'creates a new pool with the given amount of threads without spawning more than min' do
+		pool = Thread.pool(4, 8)
+
+		expect(pool.spawned).to eq(4)
+
+		pool.shutdown
+  end
+
+  it 'creates a new pool with a huge amount of threads that will handle Thread Error exception' do
+    pool = Thread.pool(3000)
+
+    expect(pool.spawned).to be<=2500
+
+    pool.shutdown
+  end
+
+	it 'properly reports the backlog length' do
+		pool = Thread.pool(2)
+
+		pool.process { sleep 0.5 }
+		pool.process { sleep 0.5 }
+		pool.process { sleep 0.5 }
+
+		sleep 0.25
+
+		expect(pool.backlog).to eq(1)
+
+		pool.shutdown
+	end
+
+	it 'properly reports the pool is done' do
+		pool = Thread.pool(2)
+
+		pool.process { sleep 0.25 }
+		pool.process { sleep 0.25 }
+		pool.process { sleep 0.25 }
+
+		expect(pool.done?).to be(false)
+
+		sleep 0.75
+
+		expect(pool.done?).to be(true)
+
+		pool.shutdown
+	end
+
+	it 'properly reports the pool is idle' do
+		pool = Thread.pool(2)
+
+		pool.process { sleep 0.25 }
+		pool.process { sleep 0.5 }
+
+		expect(pool.idle?).to be(false)
+
+		sleep 0.30
+
+		expect(pool.idle?).to be(true)
+
+		pool.shutdown
+	end
+
+	it 'properly shutdowns the pool' do
+		result = []
+		pool   = Thread.pool(4)
+
+		pool.process { sleep 0.1; result << 1 }
+		pool.process { sleep 0.2; result << 2 }
+		pool.process { sleep 0.3; result << 3 }
+		pool.process { sleep 0.4; result << 4 }
+
+		pool.shutdown
+
+		expect(result).to eq([1, 2, 3, 4])
+	end
+end

data/spec/thread/promise_spec.rb

@@ -0,0 +1,35 @@
+require 'thread/promise'
+
+describe Thread::Promise do
+	it 'delivers a value properly' do
+		p = Thread.promise
+
+		Thread.new {
+			sleep 0.02
+
+			p << 42
+		}
+
+		expect(p.value).to eq(42)
+	end
+
+	it 'properly checks if anything has been delivered' do
+		p = Thread.promise
+
+		Thread.new {
+			sleep 0.02
+
+			p << 42
+		}
+
+		expect(p.delivered?).to be(false)
+		sleep 0.03
+		expect(p.delivered?).to be(true)
+	end
+
+	it 'does not block when a timeout is passed' do
+		p = Thread.promise
+
+		expect(p.value(0)).to be(nil)
+	end
+end

data/thread.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "seekingalpha_thread"
+  spec.version       = "1.0.1"
+  spec.authors       = ["Michel Epsztejn"]
+  spec.email         = ["michel@seekingalpha.com"]
+  spec.summary       = %q{Various extensions to the base thread library.}
+  spec.description   = %q{Forked from meh/ruby-thread. Fixes thread limit exception. Includes a thread pool, message passing capabilities, a recursive mutex, promise, future and delay.}
+  spec.homepage      = "https://github.com/seekingalpha/ruby-thread"
+  spec.license       = "WTFPL"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rake"
+end