simple-thread-pool 0.0.1

data/README

@@ -0,0 +1,22 @@
+Thread Pool is meant to be an easy to use implementation of a fairly naive thread pool.  For example, here's some code that will download 100 google search queries in parallel.
+
+require 'open-uri'
+require 'thread-pool'
+
+number_of_files = 100
+number_of_files.times do |i|
+	ThreadPool.give_work("http://www.google.com/search?q=#{i}",i) do |url,index|
+		data = open(url).read
+		f = File.new("google-#{i}",'w')
+		f.puts(data)
+		f.close
+	end
+end
+
+ThreadPool.start_up(number_of_files)
+
+while ThreadPool.num_executing > 0 or ThreadPool.queue_size > 0
+  sleep(1)
+end
+
+This approach of course has its limitations, and it's important to follow best practices with respect to share resources etc..., but it does make it very easy to distribute heavily I/O bound task across a number of non-blocking processes.

data/lib/simple-thread-pool.rb

@@ -0,0 +1,64 @@
+class SimpleThreadPool
+  class << self
+    def start_up(thread_count)
+      @thread_work_queues = {}
+      @locks = {}
+      @threads = []
+      @current_jobs = {}
+      thread_count.times do |i|
+        @thread_work_queues[i] = []
+        @locks[i] = Mutex.new
+        @threads << Thread.new(i,@thread_work_queues[i],@locks[i],@current_jobs) do |index,queue,lock,executing_jobs|
+          
+          while true
+            if queue.size > 0
+              #do the mutex
+              job = nil
+              lock.synchronize { 
+                job = queue.slice!(0) 
+              }
+              if job
+                executing_jobs[index] = job
+                job[:block].call(job[:args])
+                executing_jobs.delete(index)
+              end
+              
+            end
+            #keep looking for work until the parent pid dies
+            #puts "Worker-#{index} out of stuff to do"
+            sleep(0.1)
+          end
+             
+        end
+      end
+    end
+    
+    def give_work( *args,&block)
+      min = -1
+      min_key = nil
+      @thread_work_queues.each_pair do |k,v|
+        if min_key == nil or v.size < min
+          min = v.size
+          min_key = k
+        end
+      end
+      @thread_work_queues[min_key]
+      @locks[min_key].synchronize {
+        @thread_work_queues[min_key] << {:block => block, :args => args}
+      }
+    end
+    
+    def queue_size
+      size = 0
+      @thread_work_queues.each_pair do |k,v|
+        size += v.size
+      end
+      size
+    end
+    
+    def num_executing
+      @current_jobs.keys.inject(0){|a,b| @current_jobs[b] ? a+ 1 : a }
+    end
+    
+  end
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification 
+name: simple-thread-pool
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Evan Dowling
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-02 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: dowling.evan@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- lib/simple-thread-pool.rb
+- README
+has_rdoc: true
+homepage: http://github.com/evandowling
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: A gem to package thread pools in an easy to use way
+test_files: []
+