https://github.com/bdurand/simple_thread_pool
Simple ruby thread pool for executing tasks in parallel.
https://github.com/bdurand/simple_thread_pool
ruby threadpool threads threadsafe throttle
Last synced: 7 months ago
JSON representation
Simple ruby thread pool for executing tasks in parallel.
- Host: GitHub
- URL: https://github.com/bdurand/simple_thread_pool
- Owner: bdurand
- License: mit
- Created: 2019-02-08T21:25:25.000Z (about 7 years ago)
- Default Branch: master
- Last Pushed: 2023-11-12T17:55:22.000Z (about 2 years ago)
- Last Synced: 2025-06-03T05:33:37.396Z (8 months ago)
- Topics: ruby, threadpool, threads, threadsafe, throttle
- Language: Ruby
- Size: 11.7 KB
- Stars: 1
- Watchers: 1
- Forks: 0
- Open Issues: 1
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGE_LOG.md
Awesome Lists containing this project
README
# Simple Thread Pool
[](https://github.com/bdurand/simple_thread_pool/actions/workflows/continuous_integration.yml)
[](https://github.com/bdurand/simple_thread_pool/actions/workflows/regression_test.yml)
[](https://github.com/testdouble/standard)
[](https://badge.fury.io/rb/simple_thread_pool)
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 `synchronize` method on the thread pool if you need to work with 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.synchronize { 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).