Various extensions to the thread library in ruby.
Add this line to your application's Gemfile:
gem 'thread'
Or install it yourself as:
$ gem install thread
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.
require 'thread/pool'
pool = Thread.pool(4)
10.times {
pool.process {
sleep 2
puts 'lol'
}
}
pool.shutdownYou should get 4 lols every 2 seconds and it should exit after 10 of them.
This implements a channel where you can write messages and receive messages.
require 'thread/channel'
channel = Thread.channel
channel.send 'wat'
channel.receive # => 'wat'
channel = Thread.channel { |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
}A pipe allows you to execute various tasks on a set of data in parallel, each datum inserted in the pipe is passed along through queues to the various functions composing the pipe, the final result is inserted in the final queue.
require 'thread/pipe'
p = Thread |-> d { d * 2 } |-> d { d * 4 }
p << 2
puts ~p # => 16A process helps reducing programming errors coming from race conditions and the like, the only way to interact with a process is through messages.
Multiple processes should talk with eachother through messages.
require 'thread/process'
p = Thread.process {
loop {
puts receive.inspect
}
}
p << 42
p << 23This implements the promise pattern, allowing you to pass around an object where you can send a value and extract a value, in a thread-safe way, accessing the value will wait for the value to be delivered.
require 'thread/promise'
p = Thread.promise
Thread.new {
sleep 5
p << 42
}
puts ~p # => 42A future is somewhat a promise, except you pass it a block to execute in another thread.
The value returned by the block will be the value of the promise.
By default, Thread.future executes the block in a newly-created thread.
Thread.future accepts an optional argument of type Thread.pool if you want
the block executed in an existing thread-pool.
You can also use the Thread::Pool helper #future
require 'thread/future'
f = Thread.future {
sleep 5
42
}
puts ~f # => 42require 'thread/pool'
require 'thread/future'
pool = Thread.pool 4
f = Thread.future pool do
sleep 5
42
end
puts ~f # => 42require 'thread/pool'
require 'thread/future'
pool = Thread.pool 4
f = pool.future {
sleep 5
42
}
puts ~f # => 42A delay is kind of a promise, except the block is called when the value is being accessed and the result is cached.
require 'thread/delay'
d = Thread.delay {
42
}
puts ~d # => 42An every executes the block every given seconds and yields the value to the every object, you can then check if the current value is old or how much time is left until the second call is done.
require 'net/http'
require 'thread/every'
e = Thread.every(5) {
Net::HTTP.get(URI.parse('http://www.whattimeisit.com/')).match %r{<B>(.*?)<BR>\s+(.*?)</B>}m do |m|
{ date: m[1], time: m[2] }
end
}
loop do
puts ~e
end- Fork it ( https://github.com/meh/ruby-thread/fork )
- Create your feature branch (
git checkout -b my-new-feature) - Verify new and old specs are green (
rake) - Commit your changes (
git commit -am 'Add some feature') - Push to the branch (
git push origin my-new-feature) - Create a new Pull Request
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent