Files

Class/Module Index [+]

Quicksearch

Concurrent::MutexSemaphore

@!macro [attach] semaphore

A counting semaphore. Conceptually, a semaphore maintains a set of
permits. Each {#acquire} blocks if necessary until a permit is
available, and then takes it. Each {#release} adds a permit, potentially
releasing a blocking acquirer.
However, no actual permit objects are used; the Semaphore just keeps a
count of the number available and acts accordingly.

@!visibility private

@!macro internal_implementation_note

Public Class Methods

new(count) click to toggle source

@!macro [attach] semaphore_method_initialize

Create a new `Semaphore` with the initial `count`.

@param [Fixnum] count the initial count

@raise [ArgumentError] if `count` is not an integer or is less than zero
# File lib/concurrent/atomic/semaphore.rb, line 26
def initialize(count)
  unless count.is_a?(Fixnum) && count >= 0
    fail ArgumentError, 'count must be an non-negative integer'
  end
  super()
  synchronize { ns_initialize count }
end

Public Instance Methods

acquire(permits = 1) click to toggle source

@!macro [attach] semaphore_method_acquire

Acquires the given number of permits from this semaphore,
  blocking until all are available.

@param [Fixnum] permits Number of permits to acquire

@raise [ArgumentError] if `permits` is not an integer or is less than
  one

@return [Nil]
# File lib/concurrent/atomic/semaphore.rb, line 45
def acquire(permits = 1)
  unless permits.is_a?(Fixnum) && permits > 0
    fail ArgumentError, 'permits must be an integer greater than zero'
  end
  synchronize do
    try_acquire_timed(permits, nil)
    nil
  end
end
available_permits() click to toggle source

@!macro [attach] semaphore_method_available_permits

Returns the current number of permits available in this semaphore.

@return [Integer]
# File lib/concurrent/atomic/semaphore.rb, line 60
def available_permits
  synchronize { @free }
end
drain_permits() click to toggle source

@!macro [attach] semaphore_method_drain_permits

Acquires and returns all permits that are immediately available.

@return [Integer]
# File lib/concurrent/atomic/semaphore.rb, line 69
def drain_permits
  synchronize do
    @free.tap { |_| @free = 0 }
  end
end
reduce_permits(reduction) click to toggle source

@!macro [attach] semaphore_method_reduce_permits

@api private

Shrinks the number of available permits by the indicated reduction.

@param [Fixnum] reduction Number of permits to remove.

@raise [ArgumentError] if `reduction` is not an integer or is negative

@raise [ArgumentError] if `@free` - `@reduction` is less than zero

@return [Nil]
# File lib/concurrent/atomic/semaphore.rb, line 137
def reduce_permits(reduction)
  unless reduction.is_a?(Fixnum) && reduction >= 0
    fail ArgumentError, 'reduction must be an non-negative integer'
  end
  synchronize { @free -= reduction }
  nil
end
release(permits = 1) click to toggle source

@!macro [attach] semaphore_method_release

Releases the given number of permits, returning them to the semaphore.

@param [Fixnum] permits Number of permits to return to the semaphore.

@raise [ArgumentError] if `permits` is not a number or is less than one

@return [Nil]
# File lib/concurrent/atomic/semaphore.rb, line 113
def release(permits = 1)
  unless permits.is_a?(Fixnum) && permits > 0
    fail ArgumentError, 'permits must be an integer greater than zero'
  end
  synchronize do
    @free += permits
    permits.times { ns_signal }
  end
  nil
end
try_acquire(permits = 1, timeout = nil) click to toggle source

@!macro [attach] semaphore_method_try_acquire

Acquires the given number of permits from this semaphore,
  only if all are available at the time of invocation or within
  `timeout` interval

@param [Fixnum] permits the number of permits to acquire

@param [Fixnum] timeout the number of seconds to wait for the counter
  or `nil` to return immediately

@raise [ArgumentError] if `permits` is not an integer or is less than
  one

@return [Boolean] `false` if no permits are available, `true` when
  acquired a permit
# File lib/concurrent/atomic/semaphore.rb, line 91
def try_acquire(permits = 1, timeout = nil)
  unless permits.is_a?(Fixnum) && permits > 0
    fail ArgumentError, 'permits must be an integer greater than zero'
  end
  synchronize do
    if timeout.nil?
      try_acquire_now(permits)
    else
      try_acquire_timed(permits, timeout)
    end
  end
end

Protected Instance Methods

ns_initialize(count) click to toggle source

@!visibility private

# File lib/concurrent/atomic/semaphore.rb, line 148
def ns_initialize(count)
  @free = count
end

[Validate]

Generated with the Darkfish Rdoc Generator 2.