class Concurrent::Event

Old school kernel-style event reminiscent of Win32 programming in C++.

When an ‘Event` is created it is in the `unset` state. Threads can choose to `#wait` on the event, blocking until released by another thread. When one thread wants to alert all blocking threads it calls the `#set` method which will then wake up all listeners. Once an `Event` has been set it remains set. New threads calling `#wait` will return immediately. An `Event` may be `#reset` at any time once it has been set.

@see msdn.microsoft.com/en-us/library/windows/desktop/ms682655.aspx @example

event = Concurrent::Event.new

t1 = Thread.new do
  puts "t1 is waiting"
  event.wait(1)
  puts "event occurred"
end

t2 = Thread.new do
  puts "t2 calling set"
  event.set
end

[t1, t2].each(&:join)

# prints:
# t1 is waiting
# t2 calling set
# event occurred

Public Class Methods

new() click to toggle source

Creates a new ‘Event` in the unset state. Threads calling `#wait` on the `Event` will block.

Calls superclass method
# File lib/concurrent-ruby/concurrent/atomic/event.rb, line 40
def initialize
  super
  synchronize { ns_initialize }
end

Public Instance Methods

reset() click to toggle source

Reset a previously set event back to the ‘unset` state. Has no effect if the `Event` has not yet been set.

@return [Boolean] should always return ‘true`

# File lib/concurrent-ruby/concurrent/atomic/event.rb, line 68
def reset
  synchronize do
    if @set
      @set       = false
      @iteration +=1
    end
    true
  end
end
set() click to toggle source

Trigger the event, setting the state to ‘set` and releasing all threads waiting on the event. Has no effect if the `Event` has already been set.

@return [Boolean] should always return ‘true`

# File lib/concurrent-ruby/concurrent/atomic/event.rb, line 56
def set
  synchronize { ns_set }
end
set?() click to toggle source

Is the object in the set state?

@return [Boolean] indicating whether or not the ‘Event` has been set

# File lib/concurrent-ruby/concurrent/atomic/event.rb, line 48
def set?
  synchronize { @set }
end
try?() click to toggle source
# File lib/concurrent-ruby/concurrent/atomic/event.rb, line 60
def try?
  synchronize { @set ? false : ns_set }
end
wait(timeout = nil) click to toggle source

Wait a given number of seconds for the ‘Event` to be set by another thread. Will wait forever when no `timeout` value is given. Returns immediately if the `Event` has already been set.

@return [Boolean] true if the ‘Event` was set before timeout else false

# File lib/concurrent-ruby/concurrent/atomic/event.rb, line 83
def wait(timeout = nil)
  synchronize do
    unless @set
      iteration = @iteration
      ns_wait_until(timeout) { iteration < @iteration || @set }
    else
      true
    end
  end
end

Protected Instance Methods

ns_initialize() click to toggle source
# File lib/concurrent-ruby/concurrent/atomic/event.rb, line 104
def ns_initialize
  @set       = false
  @iteration = 0
end
ns_set() click to toggle source
# File lib/concurrent-ruby/concurrent/atomic/event.rb, line 96
def ns_set
  unless @set
    @set = true
    ns_broadcast
  end
  true
end