simple_thread_pool 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3ebc46aeec19e5a7572363d8a16e3cb76a1120bfecd31467cc8c232fb5c2480c
+  data.tar.gz: 93ca2bddde18af8b14c88c2b6d346966c115d398f575467c1d5989b7025af80e
+SHA512:
+  metadata.gz: b14225a854eccedd484d1230dcc57276ee1e71cee72654d4f3030d42c9882c3a8321bdff8b148980b9e8662f8f497e814013368ec5eb26d5894807af5e7738f5
+  data.tar.gz: b8f1358b7615e9ab485416222b74fd60c8557f7462fa4088127c3aedc4b7dddc1bbcdea8a4a961ff07de73d4a4a2b8044cd05b95a006c3fc07768713a24c3f08

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/CHANGE_LOG.md

@@ -0,0 +1,3 @@
+# 1.0.0
+
+* Initial release

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in simple_thread_pool.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Brian Durand
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,76 @@
+# SimpleThreadPool
+
+Simple implementation of the thread pool to manage executing tasks in parallel. The thread pool implemented by this code is designed to allow throttled, parallel execution of tasks.
+
+Unlike some thread pools, this code does not maintain an internal queue of tasks. Instead, it simply blocks until a thread is available. This ensures that the pool memory size doesn't become bloated with 1000's of enqueued blocks of code.
+
+The threads created for running the tasks are short lived threads and are not reused by the pool. This ensures that no thread local variables can accidentally be reused between threads.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'simple_thread_pool'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install simple_thread_pool
+
+## Usage
+
+```ruby
+# Create a pool of 10 threads to work with.
+thread_pool = SimpleThreadPoolnew(10)
+
+# Execute a block of code in a thread.
+# If there are no free threads in the pool, then this will block until one is freed up.
+thread_pool.execute do
+  # Do some work here
+end
+
+# Execute a block of code with an identifier.
+# The thread pool will not run code with the same identifier in parallel
+# and will execute them in the order they are called
+thread_pool.execute("foo") do
+  # Do some work here
+end
+
+# Block until all threads have finished executing.
+# You should always call this method after all calls to `execute` have been made
+thread_pool.finish
+```
+
+### Error handling.
+
+All error handling must be conducted inside the execute block. The main thread will not be notified of any exceptions. You can use the `synchronized` method on the thread pool if you need to work data from the main thread.
+
+Example of how you can track any errors in a shared array.
+
+```ruby
+errors = []
+
+thread_pool.execute do
+  begin
+    # Do something
+  rescue Error => e
+    thread_pool.synchronized { errors << e }
+    raise e
+  end
+end
+
+thread_pool.finish
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/bdurand/simple_thread_pool.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/lib/simple_thread_pool.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'thread'
+require 'set'
+
+# Simple thread pool for executing blocks in parallel in a controlled manner.
+# Threads are not re-used by the pool to prevent any thread local variables from
+# leaking out.
+class SimpleThreadPool
+
+  def initialize(max_threads)
+    @max_threads = max_threads
+    @lock = Mutex.new
+    @threads = []
+    @processing_ids = []
+  end
+
+  # Call this method to spawn a thread to run the block. If the thread pool
+  # is already full, this method will block until a thread is free. The block
+  # is responsible for handling any exceptions that could be raised.
+  #
+  # The optional id argument can be used to provide an identifier for a block.
+  # If one is provided, processing will be blocked if the same id is already
+  # being processed. This ensures that each unique id is executed one at a time
+  # sequentially.
+  def execute(id = nil, &block)
+    loop do
+      # Check if a new thread can be added without blocking.
+      while !can_add_thread?(id)
+        sleep(0.001)
+      end
+      
+      @lock.synchronize do
+        # Check again inside a synchronized block if the thread can still be added.
+        if can_add_thread?(id)
+          @processing_ids << id unless id.nil?
+          add_thread(id, block)
+          return
+        end
+      end
+    end
+  end
+
+  # Call this method to block until all current threads have finished executing.
+  def finish
+    active_threads = @lock.synchronize { @threads.select(&:alive?) }
+    active_threads.each(&:join)
+    nil
+  end
+
+  # Synchronize data access across the thread pool. This method will block
+  # waiting on the same internal Mutex the thread pool uses to manage scheduling
+  # threads.
+  def synchronize(&block)
+    @lock.synchronize(&block)
+  end
+  
+  private
+  
+  def can_add_thread?(id)
+    @threads.size < @max_threads && (id.nil? || !@processing_ids.include?(id))
+  end
+  
+  # Spawn a thread in this method to ensure that it doesn't accidentally pick up any local variables.
+  def add_thread(id, block)
+    main_thread = Thread.current
+    
+    @threads << Thread.new do
+      begin
+        block.call
+        # Return nil to ensure no objects are leaked.
+        nil
+      ensure
+        @lock.synchronize do
+          @processing_ids.delete(id) unless id.nil?
+          @threads.delete(Thread.current)
+        end
+        main_thread.wakeup if main_thread.alive?
+      end
+    end
+
+    nil
+  end
+
+end

data/simple_thread_pool.gemspec

@@ -0,0 +1,23 @@
+Gem::Specification.new do |spec|
+  spec.name          = "simple_thread_pool"
+  spec.version       = File.read(File.expand_path("VERSION", __dir__)).chomp
+  spec.authors       = ["Brian Durand"]
+  spec.email         = ["bbdurand@gmail.com"]
+
+  spec.summary       = %q{Simple thread pool implementation to manage running tasks in parallel.}
+  spec.homepage      = "https://github.com/bdurand/simple_thread_pool"
+  spec.license       = "MIT"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.8"
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: simple_thread_pool
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Brian Durand
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-02-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+description: 
+email:
+- bbdurand@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CHANGE_LOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- lib/simple_thread_pool.rb
+- simple_thread_pool.gemspec
+homepage: https://github.com/bdurand/simple_thread_pool
+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.7.6
+signing_key: 
+specification_version: 4
+summary: Simple thread pool implementation to manage running tasks in parallel.
+test_files: []