1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
|
Timers
======
[](http://rubygems.org/gems/timers)
[](http://travis-ci.org/celluloid/timers)
[](https://codeclimate.com/github/celluloid/timers)
[](https://coveralls.io/r/celluloid/timers)
Ruby timer collections. Schedule several procs to fire after configurable delays
or at periodic intervals.
This gem is especially useful when you are faced with an API that accepts a
single timeout but you want to run multiple timers on top of it. An example of
such a library is [nio4r](https://github.com/celluloid/nio4r), a cross-platform
Ruby library for using system calls like epoll and kqueue.
Usage
-----
Create a new timer group with `Timers::Group.new`:
```ruby
require 'timers'
timers = Timers::Group.new
```
Schedule a proc to run after 5 seconds with `Timers::Group#after`:
```ruby
five_second_timer = timers.after(5) { puts "Take five" }
```
The `five_second_timer` variable is now bound to a Timers::Timer object. To
cancel a timer, use `Timers::Timer#cancel`
Once you've scheduled a timer, you can wait until the next timer fires with `Timers::Group#wait`:
```ruby
# Waits 5 seconds
timers.wait
# The script will now print "Take five"
```
You can schedule a block to run periodically with `Timers::Group#every`:
```ruby
every_five_seconds = timers.every(5) { puts "Another 5 seconds" }
loop { timers.wait }
```
You can also schedule a block to run immediately and periodically with `Timers::Group#now_and_every`:
```ruby
now_and_every_five_seconds = timers.now_and_every(5) { puts "Now and in another 5 seconds" }
loop { timers.wait }
```
If you'd like another method to do the waiting for you, e.g. `Kernel.select`,
you can use `Timers::Group#wait_interval` to obtain the amount of time to wait. When
a timeout is encountered, you can fire all pending timers with `Timers::Group#fire`:
```ruby
loop do
interval = timers.wait_interval
ready_readers, ready_writers = select readers, writers, nil, interval
if ready_readers || ready_writers
# Handle IO
...
else
# Timeout!
timers.fire
end
end
```
You can also pause and continue individual timers, or all timers:
```ruby
paused_timer = timers.every(5) { puts "I was paused" }
paused_timer.pause
10.times { timers.wait } # will not fire paused timer
paused_timer.resume
10.times { timers.wait } # will fire timer
timers.pause
10.times { timers.wait } # will not fire any timers
timers.resume
10.times { timers.wait } # will fire all timers
```
License
-------
Copyright (c) 2014 Celluloid timers project developers (given in the file
AUTHORS.md).
Distributed under the MIT License. See LICENSE file for further details.
|
