concurrent-ruby 0.7.2 → 0.8.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a55d9e304bf6ccb28a722933ea815d22d37e2698
-  data.tar.gz: 449c0ead9d820c15508ba37dfa0c14e1e724b161
+  metadata.gz: 92bfafa2b9e5e7a3b60cbf6dd6f785a8f515ae64
+  data.tar.gz: 14ca027a5eadd0daa3d10fac49860418bb9cb7bc
 SHA512:
-  metadata.gz: 52f70bfa218e39a9a2046412af4d75194b348acb7e4769108b1d3bde8dd50b03d5b51d894ede8526e40272f7888c621947f2f67a222dd9b7c9ec76736126ebd9
-  data.tar.gz: 0385dabafa663c46e71431eaae4b71436397bd982eafb51d544e48fd6abe299e900c48fa5c3c05b2cf8257b720b956a16663990965cb1ea0897a7ae706bb393a
+  metadata.gz: 7fae6fa7ae3849e3d68578eb782e13f1dd2e149260c8ef9a5dc8bef72891af0cce9e82abb697cfe72819a1e1c1385936138b63b73f59dd71fba2c9b1bc47bcb8
+  data.tar.gz: 66264191f55ab2064cb527a32c84da91550e47681f0e67856535e72b3cb23875d308b8770ec74adfa921800f9c0ae79d14b2f7f7481e545e648dd98eda9ea36a

data/CHANGELOG.md

@@ -1,19 +1,13 @@
-### Next Release v0.7.2 (24 January 2015)
+### Next Release v0.7.2 (TBD)
 
-* New `Semaphore` class based on [java.util.concurrent.Semaphore](http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Semaphore.html)
 * New `Promise.all?` and `Promise.any?` class methods
 * Renamed `:overflow_policy` on thread pools to `:fallback_policy`
 * Thread pools still accept the `:overflow_policy` option but display a warning
 * Thread pools now implement `fallback_policy` behavior when not running (rather than universally rejecting tasks)
 * Fixed minor `set_deref_options` constructor bug in `Promise` class
-* Fixed minor `require` bug in `ThreadLocalVar` class
-* Fixed race condition bug in `TimerSet` class
-* Fixed race condition bug in `TimerSet` class
-* Fixed signal bug in `TimerSet#post` method
 * Numerous non-functional updates to clear warning when running in debug mode
 * Fixed more intermittently failing tests
 * Tests now run on new Travis build environment
-* Multiple documentation updates
 
 ## Current Release v0.7.1 (4 December 2014)
 

data/README.md

@@ -38,9 +38,7 @@
 ### Supported Ruby versions
 
 MRI 1.9.3, 2.0, 2.1, JRuby (1.9 mode), and Rubinius 2.x are supported.
-Although native code is used for performance optimizations on some platforms, all functionality
-is available in pure Ruby. This gem should be fully compatible with any interpreter that is
-compliant with Ruby 1.9.3 or newer.
+This gem should be fully compatible with any interpreter that is compliant with Ruby 1.9.3 or newer.
 
 ## Features & Documentation
 
@@ -54,18 +52,19 @@ This library contains a variety of concurrency abstractions at high and low leve
 
 ### High-level, general-purpose asynchronous concurrency abstractions
 
-* [Actor](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Actor.html): Implements the Actor Model, where concurrent actors exchange messages.
-* [Agent](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Agent.html): A single atomic value that represents an identity.
-* [Async](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Async.html): A mixin module that provides simple asynchronous behavior to any standard class/object or object.
-* [Future](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Future.html): An asynchronous operation that produces a value.
-  * [Dataflow](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Dataflow.html): Built on Futures, Dataflow allows you to create a task that will be scheduled when all of its data dependencies are available.
-* [Promise](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Promise.html): Similar to Futures, with more features.
-* [ScheduledTask](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ScheduledTask.html): Like a Future scheduled for a specific future time.
+* [Actor](./doc/actor/main.md): Implements the Actor Model, where concurrent actors exchange messages. 
+* [Agent](./doc/agent.md): A single atomic value that represents an identity.
+* [Async](./doc/async.md): A mixin module that provides simple asynchronous behavior to any standard class/object or object.
+* [Future](./doc/future.md): An asynchronous operation that produces a value.
+  * [Dataflow](./doc/dataflow.md): Built on Futures, Dataflow allows you to create a task that will be scheduled when all of its data dependencies are available.
+* [Promise](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Promise.html): Similar to Futures, with more features. 
+* [ScheduledTask](./doc/scheduled_task.md): Like a Future scheduled for a specific future time. 
 * [TimerTask](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/TimerTask.html): A Thread that periodically wakes up to perform work at regular intervals. 
+* [Channel](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Channel.html): Communicating Sequential Processes (CSP). 
 
 ### Java-inspired ThreadPools and other executors
 
-* See [ThreadPool](http://ruby-concurrency.github.io/concurrent-ruby/file.thread_pools.html) overview, which also contains a list of other Executors available.
+* See [ThreadPool](./doc/thread_pools.md) overview, which also contains a list of other Executors available.
 
 ### Thread-safe Observers
 
@@ -74,7 +73,6 @@ This library contains a variety of concurrency abstractions at high and low leve
 * [CopyOnWriteObserverSet](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/CopyOnWriteObserverSet.html)
 
 ### Thread synchronization classes and algorithms
-
 Lower-level abstractions mainly used as building blocks. 
 
 * [condition](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Condition.html)
@@ -82,12 +80,10 @@ Lower-level abstractions mainly used as building blocks.
 * [cyclic barrier](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/CyclicBarrier.html)
 * [event](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Event.html)
 * [exchanger](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Exchanger.html)
-* [semaphore](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Semaphore.html)
 * [timeout](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent.html#timeout-class_method)
 * [timer](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent.html#timer-class_method)
 
 ### Thread-safe variables
-
 Lower-level abstractions mainly used as building blocks. 
 
 * [AtomicBoolean](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/AtomicBoolean.html)
@@ -96,30 +92,47 @@ Lower-level abstractions mainly used as building blocks.
 * [I-Structures](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/IVar.html) (IVar)
 * [M-Structures](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/MVar.html) (MVar)
 * [thread-local variables](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ThreadLocalVar.html)
-* [software transactional memory](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/TVar.html) (TVar)
+* [software transactional memory](./doc/tvar.md) (TVar)
 
-## Installing and Building
+## Usage
 
-This gem includes several platform-specific optimizations. To reduce the possibility of
-compilation errors, we provide pre-compiled gem packages for several platforms as well
-as a pure-Ruby build. Installing the gem should be no different than installing any other
-Rubygems-hosted gem. Rubygems will automatically detect your platform and install the
-appropriate pre-compiled build. You should never see Rubygems attempt to compile the gem
-on installation. Additionally, to ensure compatability with the largest possible number
-of Ruby interpreters, the C extensions will *never* load under any Ruby other than MRI,
-even when installed.
+All abstractions within this gem can be loaded simply by requiring it:
+
+```ruby
+require 'concurrent'
+```
 
-The following gem builds will be built at every release:
+To reduce the amount of code loaded at runtime, subsets of this gem can be required:
 
-* concurrent-ruby-x.y.z.gem (pure Ruby)
-* concurrent-ruby-x.y.z-java.gem (JRuby)
-* concurrent-ruby-x.y.z-x86-linux.gem (Linux 32-bit)
-* concurrent-ruby-x.y.z-x86_64-linux.gem (Linux 64-bit)
-* concurrent-ruby-x.y.z-x86-mingw32.gem (Windows 32-bit)
-* concurrent-ruby-x.y.z-x64-mingw32.gem (Windows 64-bit)
-* concurrent-ruby-x.y.z-x86-solaris-2.11.gem (Solaris)
+```ruby
+require 'concurrent'                # everything
+
+# groups
+
+require 'concurrent/actor'          # Concurrent::Actor and supporting code
+require 'concurrent/atomics'        # atomic and thread synchronization classes
+require 'concurrent/channels'       # Concurrent::Channel and supporting code
+require 'concurrent/executors'      # Thread pools and other executors
+require 'concurrent/utilities'      # utility methods such as processor count and timers
+
+# individual abstractions
+
+require 'concurrent/agent'          # Concurrent::Agent
+require 'concurrent/async'          # Concurrent::Async
+require 'concurrent/atomic'         # Concurrent::Atomic (formerly the `atomic` gem)
+require 'concurrent/dataflow'       # Concurrent::dataflow
+require 'concurrent/delay'          # Concurrent::Delay
+require 'concurrent/exchanger'      # Concurrent::Exchanger
+require 'concurrent/future'         # Concurrent::Future
+require 'concurrent/ivar'           # Concurrent::IVar
+require 'concurrent/mvar'           # Concurrent::MVar
+require 'concurrent/promise'        # Concurrent::Promise
+require 'concurrent/scheduled_task' # Concurrent::ScheduledTask
+require 'concurrent/timer_task'     # Concurrent::TimerTask
+require 'concurrent/tvar'           # Concurrent::TVar
+```
 
-### Installing
+## Installation
 
 ```shell
 gem install concurrent-ruby
@@ -133,33 +146,34 @@ gem 'concurrent-ruby'
 
 and run `bundle install` from your shell.
 
-### Building
+### C Extensions for MRI
 
-Because we provide pre-compiled gem builds, users should never need to build the gem manually.
-The build process for this gem is completely automated using open source tools. All of
-the automation components are available in the [ruby-concurrency/rake-compiler-dev-box](https://github.com/ruby-concurrency/rake-compiler-dev-box)
-GitHub repository.
+Potential performance improvements may be achieved under MRI by installing optional C extensions.
+To minimize installation errors the C extensions are available in the `concurrent-ruby-ext` extension
+gem. The extension gem lists `concurrent-ruby` as a dependency so it is not necessary to install both.
+Simply install the extension gen:
 
-This gem will compile native C code under MRI and native Java code under JRuby. It is
-also possible to build a pure-Ruby version. All builds have identical functionality.
-The only difference is performance. Additionally, pure-Ruby classes are always available,
-even when using the native optimizations. Please see the [documentation](http://ruby-concurrency.github.io/concurrent-ruby/)
-for more details.
+```shell
+gem install concurrent-ruby-ext
+```
 
-To build and package the gem using MRI or JRuby, install the necessary build dependencies and run:
+or add the following line to Gemfile:
 
-```shell
-bundle exec rake compile
-bundle exec rake build
+```ruby
+gem 'concurrent-ruby-ext'
 ```
 
-To build and package a pure-Ruby gem, on *any* platform and interpreter
-(including MRI and JRuby), run:
+and run `bundle install` from your shell.
+
+In code it is only necessary to
 
 ```shell
-BUILD_PURE_RUBY='true' bundle exec rake build
+require 'concurrent'
 ```
 
+The `concurrent-ruby` gem will automatically detect the presence of the `concurrent-ruby-ext` gem
+and load the appropriate C extensions.
+
 ## Maintainers
 
 * [Jerry D'Antonio](https://github.com/jdantonio)
@@ -167,6 +181,7 @@ BUILD_PURE_RUBY='true' bundle exec rake build
 * [Chris Seaton](https://github.com/chrisseaton)
 * [Lucas Allan](https://github.com/lucasallan)
 * [Petr Chalupa](https://github.com/pitr-ch)
+* [Paweł Obrok](https://github.com/obrok)
 
 ### Contributing
 

data/lib/concurrent/atomic.rb

@@ -12,6 +12,7 @@ RUBY
 end
 #####################################################################
 
+require_relative '../extension_helper'
 require 'concurrent/atomic_reference/concurrent_update_error'
 require 'concurrent/atomic_reference/mutex_atomic'
 
@@ -77,7 +78,7 @@ elsif defined? Concurrent::RbxAtomic
   class Concurrent::Atomic < Concurrent::RbxAtomic
   end
 
-elsif Concurrent.allow_c_native_class?('CAtomic')
+elsif defined? Concurrent::CAtomic
 
   # @!macro atomic_reference
   class Concurrent::Atomic < Concurrent::CAtomic

data/lib/concurrent/atomic/atomic_boolean.rb

@@ -1,5 +1,4 @@
 require_relative '../../extension_helper'
-Concurrent.safe_require_c_extensions
 
 module Concurrent
 
@@ -162,7 +161,7 @@ module Concurrent
     class AtomicBoolean < JavaAtomicBoolean
     end
 
-  elsif Concurrent.allow_c_native_class?('CAtomicBoolean')
+  elsif defined?(CAtomicBoolean)
 
     # @!macro atomic_boolean
     class CAtomicBoolean

data/lib/concurrent/atomic/atomic_fixnum.rb

@@ -1,5 +1,4 @@
 require_relative '../../extension_helper'
-Concurrent.safe_require_c_extensions
 
 module Concurrent
 
@@ -166,7 +165,7 @@ module Concurrent
     class AtomicFixnum < JavaAtomicFixnum
     end
 
-  elsif Concurrent.allow_c_native_class?('CAtomicFixnum')
+  elsif defined?(CAtomicFixnum)
 
     # @!macro atomic_fixnum
     class CAtomicFixnum

data/lib/concurrent/atomic_reference/jruby.rb

@@ -1,5 +1,4 @@
 require_relative '../../extension_helper'
-Concurrent.safe_require_java_extensions
 
 if defined?(Concurrent::JavaAtomic)
   require 'concurrent/atomic_reference/direct_update'

data/lib/concurrent/atomic_reference/ruby.rb

@@ -1,37 +1,29 @@
-require_relative '../../extension_helper'
+if defined? Concurrent::CAtomic
+  require_relative '../../extension_helper'
+  require 'concurrent/atomic_reference/direct_update'
+  require 'concurrent/atomic_reference/numeric_cas_wrapper'
 
-if Concurrent.allow_c_extensions?
-  begin
-    require 'concurrent_ruby_ext'
-  rescue LoadError
-    # may be a Windows cross-compiled native gem
-    require "#{RUBY_VERSION[0..2]}/concurrent_ruby_ext"
-  end
-end
-
-require 'concurrent/atomic_reference/direct_update'
-require 'concurrent/atomic_reference/numeric_cas_wrapper'
-
-module Concurrent
+  module Concurrent
 
-  # @!macro atomic_reference
-  class CAtomic
-    include Concurrent::AtomicDirectUpdate
-    include Concurrent::AtomicNumericCompareAndSetWrapper
+    # @!macro atomic_reference
+    class CAtomic
+      include Concurrent::AtomicDirectUpdate
+      include Concurrent::AtomicNumericCompareAndSetWrapper
 
-    # @!method initialize
-    #   @!macro atomic_reference_method_initialize
+      # @!method initialize
+      #   @!macro atomic_reference_method_initialize
 
-    # @!method get
-    #   @!macro atomic_reference_method_get
+      # @!method get
+      #   @!macro atomic_reference_method_get
 
-    # @!method set
-    #   @!macro atomic_reference_method_set
+      # @!method set
+      #   @!macro atomic_reference_method_set
 
-    # @!method get_and_set
-    #   @!macro atomic_reference_method_get_and_set
+      # @!method get_and_set
+      #   @!macro atomic_reference_method_get_and_set
 
-    # @!method _compare_and_set
-    #   @!macro atomic_reference_method_compare_and_set
+      # @!method _compare_and_set
+      #   @!macro atomic_reference_method_compare_and_set
+    end
   end
 end

data/lib/concurrent/atomics.rb

@@ -8,5 +8,3 @@ require 'concurrent/atomic/cyclic_barrier'
 require 'concurrent/atomic/count_down_latch'
 require 'concurrent/atomic/event'
 require 'concurrent/atomic/synchronization'
-require 'concurrent/atomic/semaphore'
-require 'concurrent/atomic/thread_local_var'

data/lib/concurrent/executor/thread_pool_executor.rb

@@ -49,6 +49,8 @@ module Concurrent
     #   * `:discard`: Discard the task and return false.
     #   * `:caller_runs`: Execute the task on the calling thread.
     #
+    #   {include:file:doc/thread_pools.md}
+    #
     #   @note When running on the JVM (JRuby) this class will inherit from `JavaThreadPoolExecutor`.
     #     On all other platforms it will inherit from `RubyThreadPoolExecutor`.
     #

data/lib/concurrent/executor/timer_set.rb

@@ -55,10 +55,10 @@ module Concurrent
           @queue.push(Task.new(time, args, task))
           @timer_executor.post(&method(:process_tasks))
         end
+
+        true
       end
 
-      @condition.signal
-      true
     end
 
     # For a timer, #kill is like an orderly shutdown, except we need to manually
@@ -129,20 +129,8 @@ module Concurrent
         interval = task.time - Time.now.to_f
 
         if interval <= 0
-          # We need to remove the task from the queue before passing
-          # it to the executor, to avoid race conditions where we pass
-          # the peek'ed task to the executor and then pop a different
-          # one that's been added in the meantime.
-          #
-          # Note that there's no race condition between the peek and
-          # this pop - this pop could retrieve a different task from
-          # the peek, but that task would be due to fire now anyway
-          # (because @queue is a priority queue, and this thread is
-          # the only reader, so whatever timer is at the head of the
-          # queue now must have the same pop time, or a closer one, as
-          # when we peeked).
-          task = mutex.synchronize { @queue.pop }
           @task_executor.post(*task.args, &task.op)
+          mutex.synchronize { @queue.pop }
         else
           mutex.synchronize do
             @condition.wait(mutex, [interval, 60].min)

data/lib/concurrent/version.rb

@@ -1,3 +1,4 @@
 module Concurrent
-  VERSION = '0.7.2'
+  VERSION = '0.8.0.pre1'
+  EXT_VERSION = '0.1.0.pre1'
 end

data/lib/extension_helper.rb

@@ -1,28 +1,32 @@
 module Concurrent
+  
+  @@c_ext_loaded ||= false
+  @@java_ext_loaded ||= false
 
   # @!visibility private
   def self.allow_c_extensions?
     defined?(RUBY_ENGINE) && RUBY_ENGINE == 'ruby'
   end
 
-  # @!visibility private
-  def self.allow_c_native_class?(clazz)
-    allow_c_extensions? && Concurrent.const_defined?(clazz)
-  rescue
-    false
-  end
-
-  # @!visibility private
-  def self.safe_require_c_extensions
-    require 'concurrent_ruby_ext' if allow_c_extensions?
-  rescue LoadError
-    #warn 'Attempted to load C extensions on unsupported platform. Continuing with pure-Ruby.'
-  end
-
-  # @!visibility private
-  def self.safe_require_java_extensions
-    require 'concurrent_ruby_ext' if RUBY_PLATFORM == 'java'
-  rescue LoadError
-    #warn 'Attempted to load Java extensions on unsupported platform. Continuing with pure-Ruby.'
+  if allow_c_extensions? && !@@c_ext_loaded
+    begin
+      require 'concurrent_ruby_ext'
+      @@c_ext_loaded = true
+    rescue LoadError
+      # may be a Windows cross-compiled native gem
+      begin
+        require "#{RUBY_VERSION[0..2]}/concurrent_ruby_ext"
+        @@c_ext_loaded = true
+      rescue LoadError
+        warn 'Performance on MRI may be improved with the concurrent-ruby-ext gem. Please see http://concurrent-ruby.com'
+      end
+    end
+  elsif RUBY_PLATFORM == 'java' && !@@java_ext_loaded
+    begin
+      require 'concurrent_ruby_ext'
+      @@java_ext_loaded = true
+    rescue LoadError
+      #warn 'Attempted to load Java extensions on unsupported platform. Continuing with pure-Ruby.'
+    end
   end
 end

metadata

@@ -1,20 +1,23 @@
 --- !ruby/object:Gem::Specification
 name: concurrent-ruby
 version: !ruby/object:Gem::Version
-  version: 0.7.2
+  version: 0.8.0.pre1
 platform: ruby
 authors:
 - Jerry D'Antonio
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-24 00:00:00.000000000 Z
+date: 2014-12-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ref
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.0.5
   type: :runtime
@@ -22,6 +25,9 @@ dependencies:
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.0.5
 description: |2
@@ -81,7 +87,6 @@ files:
 - lib/concurrent/atomic/count_down_latch.rb
 - lib/concurrent/atomic/cyclic_barrier.rb
 - lib/concurrent/atomic/event.rb
-- lib/concurrent/atomic/semaphore.rb
 - lib/concurrent/atomic/synchronization.rb
 - lib/concurrent/atomic/thread_local_var.rb
 - lib/concurrent/atomic_reference/concurrent_update_error.rb
@@ -162,9 +167,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.4.5

data/lib/concurrent/atomic/semaphore.rb

@@ -1,232 +0,0 @@
-require 'concurrent/atomic/condition'
-
-module Concurrent
-  class MutexSemaphore
-    # @!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
-    def initialize(count)
-      unless count.is_a?(Fixnum) && count >= 0
-        fail ArgumentError, 'count must be an non-negative integer'
-      end
-      @mutex = Mutex.new
-      @condition = Condition.new
-      @free = count
-    end
-
-    # @!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]
-    def acquire(permits = 1)
-      unless permits.is_a?(Fixnum) && permits > 0
-        fail ArgumentError, 'permits must be an integer greater than zero'
-      end
-      @mutex.synchronize do
-        try_acquire_timed(permits, nil)
-        nil
-      end
-    end
-
-    # @!macro [attach] semaphore_method_available_permits
-    #
-    #   Returns the current number of permits available in this semaphore.
-    #
-    #   @return [Integer]
-    def available_permits
-      @mutex.synchronize { @free }
-    end
-
-    # @!macro [attach] semaphore_method_drain_permits
-    #
-    #   Acquires and returns all permits that are immediately available.
-    #
-    #   @return [Integer]
-    def drain_permits
-      @mutex.synchronize do
-        @free.tap { |_| @free = 0 }
-      end
-    end
-
-    # @!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
-    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
-      @mutex.synchronize do
-        if timeout.nil?
-          try_acquire_now(permits)
-        else
-          try_acquire_timed(permits, timeout)
-        end
-      end
-    end
-
-    # @!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]
-    def release(permits = 1)
-      unless permits.is_a?(Fixnum) && permits > 0
-        fail ArgumentError, 'permits must be an integer greater than zero'
-      end
-      @mutex.synchronize do
-        @free += permits
-        permits.times { @condition.signal }
-      end
-      nil
-    end
-
-    # @!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]
-    def reduce_permits(reduction)
-      unless reduction.is_a?(Fixnum) && reduction >= 0
-        fail ArgumentError, 'reduction must be an non-negative integer'
-      end
-      @mutex.synchronize { @free -= reduction }
-      nil 
-    end
-
-    private
-
-    def try_acquire_now(permits)
-      if @free >= permits
-        @free -= permits
-        true
-      else
-        false
-      end
-    end
-
-    def try_acquire_timed(permits, timeout)
-      remaining = Condition::Result.new(timeout)
-      while !try_acquire_now(permits) && remaining.can_wait?
-        @condition.signal
-        remaining = @condition.wait(@mutex, remaining.remaining_time)
-      end
-      remaining.can_wait? ? true : false
-    end
-  end
-
-  if RUBY_PLATFORM == 'java'
-
-    # @!macro 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.
-    class JavaSemaphore
-      # @!macro semaphore_method_initialize
-      def initialize(count)
-        unless count.is_a?(Fixnum) && count >= 0
-          fail(ArgumentError,
-               'count must be in integer greater than or equal zero')
-        end
-        @semaphore = java.util.concurrent.Semaphore.new(count)
-      end
-
-      # @!macro semaphore_method_acquire
-      def acquire(permits = 1)
-        unless permits.is_a?(Fixnum) && permits > 0
-          fail ArgumentError, 'permits must be an integer greater than zero'
-        end
-        @semaphore.acquire(permits)
-      end
-
-      # @!macro semaphore_method_available_permits
-      def available_permits
-        @semaphore.availablePermits
-      end
-
-      # @!macro semaphore_method_drain_permits
-      def drain_permits
-        @semaphore.drainPermits
-      end
-
-      # @!macro semaphore_method_try_acquire
-      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
-        if timeout.nil?
-          @semaphore.tryAcquire(permits)
-        else
-          @semaphore.tryAcquire(permits,
-                                 timeout,
-                                 java.util.concurrent.TimeUnit::SECONDS)
-        end
-      end
-
-      # @!macro semaphore_method_release
-      def release(permits = 1)
-        unless permits.is_a?(Fixnum) && permits > 0
-          fail ArgumentError, 'permits must be an integer greater than zero'
-        end
-        @semaphore.release(permits)
-        true
-      end
-
-      # @!macro semaphore_method_reduce_permits
-      def reduce_permits(reduction)
-        unless reduction.is_a?(Fixnum) && reduction >= 0
-          fail ArgumentError, 'reduction must be an non-negative integer'
-        end
-        @semaphore.reducePermits(reduction)
-      end
-    end
-
-    # @!macro semaphore
-    class Semaphore < JavaSemaphore
-    end
-
-  else
-
-    # @!macro semaphore
-    class Semaphore < MutexSemaphore
-    end
-  end
-end