class Concurrent::CyclicBarrier

def broken?

Returns:
  • (Boolean) - true if the barrier is broken otherwise false 
def broken?
  @mutex.synchronize { @generation.status != :waiting }
end

def initialize(parties, &block)

Raises:
  • (ArgumentError) - if `parties` is not an integer or is less than zero

Other tags:
    Yield: - an optional block that will be executed that will be executed after the last thread arrives and before the others are released

Parameters:
  • parties (Fixnum) -- the number of parties 
def initialize(parties, &block)
  raise ArgumentError.new('count must be in integer greater than or equal zero') if !parties.is_a?(Fixnum) || parties < 1
  @parties = parties
  @mutex = Mutex.new
  @condition = Condition.new
  @number_waiting = 0
  @action = block
  @generation = Generation.new(:waiting)
end

def number_waiting

Returns:
  • (Fixnum) - the number of threads currently waiting on the barrier 
def number_waiting
  @number_waiting
end

def parties

Returns:
  • (Fixnum) - the number of threads needed to pass the barrier 
def parties
  @parties
end

def reset

Returns:
  • (nil) - 
def reset
  @mutex.synchronize do
    set_status_and_restore(:reset)
  end
end

def set_status_and_restore(new_status) 

def set_status_and_restore(new_status)
  @generation.status = new_status
  @condition.broadcast
  @generation = Generation.new(:waiting)
  @number_waiting = 0
end

def wait(timeout = nil)

Returns:
  • (Boolean) - `true` if the `count` reaches zero else false on `timeout` or on `reset` or if the barrier is broken

Parameters:
  • timeout (Fixnum) -- the number of seconds to wait for the counter or `nil` to block indefinitely 
def wait(timeout = nil)
  @mutex.synchronize do
    return false unless @generation.status == :waiting
    @number_waiting += 1
    if @number_waiting == @parties
      @action.call if @action
      set_status_and_restore(:fulfilled)
      true
    else
      wait_for_wake_up(@generation, timeout)
    end
  end
end

def wait_for_wake_up(generation, timeout) 

def wait_for_wake_up(generation, timeout)
  if wait_while_waiting(generation, timeout)
    generation.status == :fulfilled
  else
    generation.status = :broken
    @condition.broadcast
    false
  end
end

def wait_while_waiting(generation, timeout) 

def wait_while_waiting(generation, timeout)
  remaining = Condition::Result.new(timeout)
  while generation.status == :waiting && remaining.can_wait?
    remaining = @condition.wait(@mutex, remaining.remaining_time)
  end
  remaining.woken_up?
end