Gecko [ lorencats.com ]

Name	Size	Permission
abstract_thread_local_var.rb	1.3 KB	-rw-r--r--
atomic_boolean.rb	3.8 KB	-rw-r--r--
atomic_fixnum.rb	4.51 KB	-rw-r--r--
atomic_reference.rb	1.27 KB	-rw-r--r--
count_down_latch.rb	3.24 KB	-rw-r--r--
cyclic_barrier.rb	3.99 KB	-rw-r--r--
event.rb	2.76 KB	-rw-r--r--
java_count_down_latch.rb	964 B	-rw-r--r--
java_thread_local_var.rb	691 B	-rw-r--r--
mutex_atomic_boolean.rb	1.23 KB	-rw-r--r--
mutex_atomic_fixnum.rb	1.55 KB	-rw-r--r--
mutex_count_down_latch.rb	970 B	-rw-r--r--
mutex_semaphore.rb	2.7 KB	-rw-r--r--
read_write_lock.rb	8.22 KB	-rw-r--r--
reentrant_read_write_lock.rb	13.87 KB	-rw-r--r--
ruby_thread_local_var.rb	4.85 KB	-rw-r--r--
semaphore.rb	4.15 KB	-rw-r--r--
thread_local_var.rb	3.01 KB	-rw-r--r--

Code Editor : semaphore.rb

require 'concurrent/atomic/mutex_semaphore'
require 'concurrent/synchronization'

module Concurrent

###################################################################

# @!macro [new] 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

# @!macro [new] 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]

# @!macro [new] semaphore_method_available_permits
  #
  #   Returns the current number of permits available in this semaphore.
  #
  #   @return [Integer]

# @!macro [new] semaphore_method_drain_permits
  #
  #   Acquires and returns all permits that are immediately available.
  #
  #   @return [Integer]

# @!macro [new] 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

# @!macro [new] 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]

###################################################################

# @!macro [new] semaphore_public_api
  #
  #   @!method initialize(count)
  #     @!macro semaphore_method_initialize
  #
  #   @!method acquire(permits = 1)
  #     @!macro semaphore_method_acquire
  #
  #   @!method available_permits
  #     @!macro semaphore_method_available_permits
  #
  #   @!method drain_permits
  #     @!macro semaphore_method_drain_permits
  #
  #   @!method try_acquire(permits = 1, timeout = nil)
  #     @!macro semaphore_method_try_acquire
  #
  #   @!method release(permits = 1)
  #     @!macro semaphore_method_release

###################################################################

# @!visibility private
  # @!macro internal_implementation_note
  SemaphoreImplementation = case
                            when defined?(JavaSemaphore)
                              JavaSemaphore
                            else
                              MutexSemaphore
                            end
  private_constant :SemaphoreImplementation

# @!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.
  #
  # @!macro semaphore_public_api
  # @example
  #   semaphore = Concurrent::Semaphore.new(2)
  #
  #   t1 = Thread.new do
  #     semaphore.acquire
  #     puts "Thread 1 acquired semaphore"
  #   end
  #
  #   t2 = Thread.new do
  #     semaphore.acquire
  #     puts "Thread 2 acquired semaphore"
  #   end
  #
  #   t3 = Thread.new do
  #     semaphore.acquire
  #     puts "Thread 3 acquired semaphore"
  #   end
  #
  #   t4 = Thread.new do
  #     sleep(2)
  #     puts "Thread 4 releasing semaphore"
  #     semaphore.release
  #   end
  #
  #   [t1, t2, t3, t4].each(&:join)
  #
  #   # prints:
  #   # Thread 3 acquired semaphore
  #   # Thread 2 acquired semaphore
  #   # Thread 4 releasing semaphore
  #   # Thread 1 acquired semaphore
  #
  class Semaphore < SemaphoreImplementation
  end
end

${this.title}

Code Editor : semaphore.rb