Class: Concurrent::CountDownLatch

Inherits:
Object
  • Object
show all
Defined in:
lib/concurrent/count_down_latch.rb

Overview

A synchronization object that allows one thread to wait on multiple other threads. The thread that will wait creates a CountDownLatch and sets the initial value (normally equal to the number of other threads). The initiating thread passes the latch to the other threads then waits for the other threads by calling the #wait method. Each of the other threads calls #count_down when done with its work. When the latch counter reaches zero the waiting thread is unblocked and continues with its work. A CountDownLatch can be used only once. Its value cannot be reset.

Instance Method Summary collapse

Constructor Details

#initialize(count) ⇒ CountDownLatch

Create a new CountDownLatch with the initial count.

Parameters:

  • count (Fixnum) —

    the initial count

Raises:

  • (ArgumentError) —

    if count is not an integer or is less than zero



17
18
19
20
21
22
23
24
 
# File 'lib/concurrent/count_down_latch.rb', line 17

def initialize(count)
  unless count.is_a?(Fixnum) && count >= 0
    raise ArgumentError.new('count must be in integer greater than or equal zero')
  end
  @mutex = Mutex.new
  @condition = Condition.new
  @count = count
end

Instance Method Details

#count ⇒ Fixnum

The current value of the counter.

Returns:

  • (Fixnum) —

    the current value of the counter



55
56
57
 
# File 'lib/concurrent/count_down_latch.rb', line 55

def count
  @mutex.synchronize { @count }
end

#count_down ⇒ Object

Signal the latch to decrement the counter. Will signal all blocked threads when the count reaches zero.



45
46
47
48
49
50
 
# File 'lib/concurrent/count_down_latch.rb', line 45

def count_down
  @mutex.synchronize do
    @count -= 1 if @count > 0
    @condition.broadcast if @count == 0
  end
end

#wait(timeout = nil) ⇒ Boolean

Block on the latch until the counter reaches zero or until timeout is reached.

Parameters:

  • timeout (Fixnum) (defaults to: nil) —

    the number of seconds to wait for the counter or nil to block indefinitely

Returns:

  • (Boolean) —

    true if the count reaches zero else false on timeout



31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/concurrent/count_down_latch.rb', line 31

def wait(timeout = nil)
  @mutex.synchronize do

    remaining = Condition::Result.new(timeout)
    while @count > 0 && remaining.can_wait?
      remaining = @condition.wait(@mutex, remaining.remaining_time)
    end

    @count == 0
  end
end