concurrent-ruby 0.8.0.pre2-java → 0.9.0-java

data/lib/concurrent/atomics.rb

@@ -1,12 +1,82 @@
-require 'concurrent/atomic'
+# @!macro [new] atomic_reference
+#
+#   An object reference that may be updated atomically.
+#
+#       Testing with ruby 2.1.2
+#       
+#       *** Sequential updates ***
+#                                 user     system      total        real
+#       no lock               0.000000   0.000000   0.000000 (  0.005502)
+#       mutex                 0.030000   0.000000   0.030000 (  0.025158)
+#       MutexAtomicReference  0.100000   0.000000   0.100000 (  0.103096)
+#       CAtomicReference      0.040000   0.000000   0.040000 (  0.034012)
+#       
+#       *** Parallel updates ***
+#                                 user     system      total        real
+#       no lock               0.010000   0.000000   0.010000 (  0.009387)
+#       mutex                 0.030000   0.010000   0.040000 (  0.032545)
+#       MutexAtomicReference  0.830000   2.280000   3.110000 (  2.146622)
+#       CAtomicReference      0.040000   0.000000   0.040000 (  0.038332)
+#
+#       Testing with jruby 1.9.3
+#       
+#       *** Sequential updates ***
+#                                 user     system      total        real
+#       no lock               0.170000   0.000000   0.170000 (  0.051000)
+#       mutex                 0.370000   0.010000   0.380000 (  0.121000)
+#       MutexAtomicReference  1.530000   0.020000   1.550000 (  0.471000)
+#       JavaAtomicReference   0.370000   0.010000   0.380000 (  0.112000)
+#       
+#       *** Parallel updates ***
+#                                 user     system      total        real
+#       no lock               0.390000   0.000000   0.390000 (  0.105000)
+#       mutex                 0.480000   0.040000   0.520000 (  0.145000)
+#       MutexAtomicReference  1.600000   0.180000   1.780000 (  0.511000)
+#       JavaAtomicReference   0.460000   0.010000   0.470000 (  0.131000)
+#
+#   @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/AtomicReference.html
+#   @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/package-summary.html
+#
+#   @!method initialize
+#     @!macro [new] atomic_reference_method_initialize
+#       @param [Object] value The initial value.
+#   
+#   @!method get
+#     @!macro [new] atomic_reference_method_get
+#       Gets the current value.
+#       @return [Object] the current value
+#   
+#   @!method set
+#     @!macro [new] atomic_reference_method_set
+#       Sets to the given value.
+#       @param [Object] new_value the new value
+#       @return [Object] the new value
+#   
+#   @!method get_and_set
+#     @!macro [new] atomic_reference_method_get_and_set
+#       Atomically sets to the given value and returns the old value.
+#       @param [Object] new_value the new value
+#       @return [Object] the old value
+#   
+#   @!method compare_and_set
+#     @!macro [new] atomic_reference_method_compare_and_set
+#
+#       Atomically sets the value to the given updated value if
+#       the current value == the expected value.
+#
+#       @param [Object] old_value the expected value
+#       @param [Object] new_value the new value
+#
+#       @return [Boolean] `true` if successful. A `false` return indicates
+#       that the actual value was not equal to the expected value.
+
+require 'concurrent/atomic/atomic_reference'
 require 'concurrent/atomic/atomic_boolean'
 require 'concurrent/atomic/atomic_fixnum'
 require 'concurrent/atomic/condition'
-require 'concurrent/atomic/copy_on_notify_observer_set'
-require 'concurrent/atomic/copy_on_write_observer_set'
 require 'concurrent/atomic/cyclic_barrier'
 require 'concurrent/atomic/count_down_latch'
 require 'concurrent/atomic/event'
-require 'concurrent/atomic/synchronization'
+require 'concurrent/atomic/read_write_lock'
 require 'concurrent/atomic/semaphore'
 require 'concurrent/atomic/thread_local_var'

data/lib/concurrent/collection/copy_on_notify_observer_set.rb

@@ -0,0 +1,115 @@
+require 'concurrent/synchronization'
+
+module Concurrent
+  module Collection
+
+    # A thread safe observer set implemented using copy-on-read approach:
+    # observers are added and removed from a thread safe collection; every time
+    # a notification is required the internal data structure is copied to
+    # prevent concurrency issues
+    # 
+    # @api private
+    class CopyOnNotifyObserverSet < Synchronization::Object
+
+      def initialize
+        super()
+        synchronize { ns_initialize }
+      end
+
+      # Adds an observer to this set. If a block is passed, the observer will be
+      # created by this method and no other params should be passed
+      #
+      # @param [Object] observer the observer to add
+      # @param [Symbol] func the function to call on the observer during notification.
+      #   Default is :update
+      # @return [Object] the added observer
+      def add_observer(observer=nil, func=:update, &block)
+        if observer.nil? && block.nil?
+          raise ArgumentError, 'should pass observer as a first argument or block'
+        elsif observer && block
+          raise ArgumentError.new('cannot provide both an observer and a block')
+        end
+
+        if block
+          observer = block
+          func     = :call
+        end
+
+        synchronize do
+          @observers[observer] = func
+          observer
+        end
+      end
+
+      # @param [Object] observer the observer to remove
+      # @return [Object] the deleted observer
+      def delete_observer(observer)
+        synchronize do
+          @observers.delete(observer)
+          observer
+        end
+      end
+
+      # Deletes all observers
+      # @return [CopyOnWriteObserverSet] self
+      def delete_observers
+        synchronize do
+          @observers.clear
+          self
+        end
+      end
+
+      # @return [Integer] the observers count
+      def count_observers
+        synchronize { @observers.count }
+      end
+
+      # Notifies all registered observers with optional args
+      # @param [Object] args arguments to be passed to each observer
+      # @return [CopyOnWriteObserverSet] self
+      def notify_observers(*args, &block)
+        observers = duplicate_observers
+        notify_to(observers, *args, &block)
+        self
+      end
+
+      # Notifies all registered observers with optional args and deletes them.
+      #
+      # @param [Object] args arguments to be passed to each observer
+      # @return [CopyOnWriteObserverSet] self
+      def notify_and_delete_observers(*args, &block)
+        observers = duplicate_and_clear_observers
+        notify_to(observers, *args, &block)
+        self
+      end
+
+      protected
+
+      def ns_initialize
+        @observers = {}
+      end
+
+      private
+
+      def duplicate_and_clear_observers
+        synchronize do
+          observers = @observers.dup
+          @observers.clear
+          observers
+        end
+      end
+
+      def duplicate_observers
+        synchronize { observers = @observers.dup }
+      end
+
+      def notify_to(observers, *args)
+        raise ArgumentError.new('cannot give arguments and a block') if block_given? && !args.empty?
+        observers.each do |observer, function|
+          args = yield if block_given?
+          observer.send(function, *args)
+        end
+      end
+    end
+  end
+end

data/lib/concurrent/collection/copy_on_write_observer_set.rb

@@ -0,0 +1,119 @@
+require 'concurrent/synchronization'
+
+module Concurrent
+  module Collection
+
+    # A thread safe observer set implemented using copy-on-write approach:
+    # every time an observer is added or removed the whole internal data structure is
+    # duplicated and replaced with a new one.
+    # 
+    # @api private
+    class CopyOnWriteObserverSet < Synchronization::Object
+
+      def initialize
+        super()
+        synchronize { ns_initialize }
+      end
+
+      # Adds an observer to this set
+      # If a block is passed, the observer will be created by this method and no
+      #   other params should be passed
+      # @param [Object] observer the observer to add
+      # @param [Symbol] func the function to call on the observer during notification.
+      #   Default is :update
+      # @return [Object] the added observer
+      def add_observer(observer=nil, func=:update, &block)
+        if observer.nil? && block.nil?
+          raise ArgumentError, 'should pass observer as a first argument or block'
+        elsif observer && block
+          raise ArgumentError.new('cannot provide both an observer and a block')
+        end
+
+        if block
+          observer = block
+          func = :call
+        end
+
+        synchronize do
+          new_observers = @observers.dup
+          new_observers[observer] = func
+          @observers = new_observers
+          observer
+        end
+      end
+
+      # @param [Object] observer the observer to remove
+      # @return [Object] the deleted observer
+      def delete_observer(observer)
+        synchronize do
+          new_observers = @observers.dup
+          new_observers.delete(observer)
+          @observers = new_observers
+          observer
+        end
+      end
+
+      # Deletes all observers
+      # @return [CopyOnWriteObserverSet] self
+      def delete_observers
+        self.observers = {}
+        self
+      end
+
+      # @return [Integer] the observers count
+      def count_observers
+        observers.count
+      end
+
+      # Notifies all registered observers with optional args
+      # @param [Object] args arguments to be passed to each observer
+      # @return [CopyOnWriteObserverSet] self
+      def notify_observers(*args, &block)
+        notify_to(observers, *args, &block)
+        self
+      end
+
+      # Notifies all registered observers with optional args and deletes them.
+      #
+      # @param [Object] args arguments to be passed to each observer
+      # @return [CopyOnWriteObserverSet] self
+      def notify_and_delete_observers(*args, &block)
+        old = clear_observers_and_return_old
+        notify_to(old, *args, &block)
+        self
+      end
+
+      protected
+
+      def ns_initialize
+        @observers = {}
+      end
+
+      private
+
+      def notify_to(observers, *args)
+        raise ArgumentError.new('cannot give arguments and a block') if block_given? && !args.empty?
+        observers.each do |observer, function|
+          args = yield if block_given?
+          observer.send(function, *args)
+        end
+      end
+
+      def observers
+        synchronize { @observers }
+      end
+
+      def observers=(new_set)
+        synchronize { @observers = new_set }
+      end
+
+      def clear_observers_and_return_old
+        synchronize do
+          old_observers = @observers
+          @observers = {}
+          old_observers
+        end
+      end
+    end
+  end
+end

data/lib/concurrent/collection/priority_queue.rb

@@ -1,305 +1,360 @@
 module Concurrent
+  module Collection
 
-  # @!macro [attach] priority_queue
-  #
-  #   A queue collection in which the elements are sorted based on their
-  #   comparison (spaceship) operator `<=>`. Items are added to the queue
-  #   at a position relative to their priority. On removal the element
-  #   with the "highest" priority is removed. By default the sort order is
-  #   from highest to lowest, but a lowest-to-highest sort order can be
-  #   set on construction.
-  #
-  #   The API is based on the `Queue` class from the Ruby standard library.
-  #
-  #   The pure Ruby implementation, `MutexPriorityQueue` uses a heap algorithm
-  #   stored in an array. The algorithm is based on the work of Robert Sedgewick
-  #   and Kevin Wayne.
-  #
-  #   The JRuby native implementation is a thin wrapper around the standard
-  #   library `java.util.PriorityQueue`.
-  #
-  #   When running under JRuby the class `PriorityQueue` extends `JavaPriorityQueue`.
-  #   When running under all other interpreters it extends `MutexPriorityQueue`.
-  #
-  #   @note This implementation is *not* thread safe and performs no blocking.
-  #
-  #   @see http://en.wikipedia.org/wiki/Priority_queue
-  #   @see http://ruby-doc.org/stdlib-2.0.0/libdoc/thread/rdoc/Queue.html
-  #
-  #   @see http://algs4.cs.princeton.edu/24pq/index.php#2.6
-  #   @see http://algs4.cs.princeton.edu/24pq/MaxPQ.java.html
-  #
-  #   @see http://docs.oracle.com/javase/7/docs/api/java/util/PriorityQueue.html
-  class MutexPriorityQueue
-
-    # @!macro [attach] priority_queue_method_initialize
+    # @!macro [attach] priority_queue
     #
-    #   Create a new priority queue with no items.
-    #  
-    #   @param [Hash] opts the options for creating the queue
-    #   @option opts [Symbol] :order (:max) dictates the order in which items are
-    #     stored: from highest to lowest when `:max` or `:high`; from lowest to
-    #     highest when `:min` or `:low`
-    def initialize(opts = {})
-      order = opts.fetch(:order, :max)
-      @comparator = [:min, :low].include?(order) ? -1 : 1
-      clear
-    end
-
-    # @!macro [attach] priority_queue_method_clear
+    #   A queue collection in which the elements are sorted based on their
+    #   comparison (spaceship) operator `<=>`. Items are added to the queue
+    #   at a position relative to their priority. On removal the element
+    #   with the "highest" priority is removed. By default the sort order is
+    #   from highest to lowest, but a lowest-to-highest sort order can be
+    #   set on construction.
     #
-    #   Removes all of the elements from this priority queue.
-    def clear
-      @queue = [nil]
-      @length = 0
-      true
-    end
-
-    # @!macro [attach] priority_queue_method_delete
+    #   The API is based on the `Queue` class from the Ruby standard library.
     #
-    #   Deletes all items from `self` that are equal to `item`.
-    #  
-    #   @param [Object] item the item to be removed from the queue
-    #   @return [Object] true if the item is found else false
-    def delete(item)
-      original_length = @length
-      k = 1
-      while k <= @length
-        if @queue[k] == item
-          swap(k, @length)
-          @length -= 1
-          sink(k)
-          @queue.pop
-        else
-          k += 1
-        end
-      end
-      @length != original_length
-    end
-
-    # @!macro [attach] priority_queue_method_empty
-    #  
-    #   Returns `true` if `self` contains no elements.
-    #  
-    #   @return [Boolean] true if there are no items in the queue else false
-    def empty?
-      size == 0
-    end
-
-    # @!macro [attach] priority_queue_method_include
+    #   The pure Ruby implementation, `MutexPriorityQueue` uses a heap algorithm
+    #   stored in an array. The algorithm is based on the work of Robert Sedgewick
+    #   and Kevin Wayne.
     #
-    #   Returns `true` if the given item is present in `self` (that is, if any
-    #   element == `item`), otherwise returns false.
-    #  
-    #   @param [Object] item the item to search for
-    #  
-    #   @return [Boolean] true if the item is found else false
-    def include?(item)
-      @queue.include?(item)
-    end
-    alias_method :has_priority?, :include?
-
-    # @!macro [attach] priority_queue_method_length
-    #  
-    #   The current length of the queue.
-    #  
-    #   @return [Fixnum] the number of items in the queue
-    def length
-      @length
-    end
-    alias_method :size, :length
-
-    # @!macro [attach] priority_queue_method_peek
-    #  
-    #   Retrieves, but does not remove, the head of this queue, or returns `nil`
-    #   if this queue is empty.
-    #   
-    #   @return [Object] the head of the queue or `nil` when empty
-    def peek
-      @queue[1]
-    end
-
-    # @!macro [attach] priority_queue_method_pop
-    #  
-    #   Retrieves and removes the head of this queue, or returns `nil` if this
-    #   queue is empty.
-    #   
-    #   @return [Object] the head of the queue or `nil` when empty
-    def pop
-      max = @queue[1]
-      swap(1, @length)
-      @length -= 1
-      sink(1)
-      @queue.pop
-      max
-    end
-    alias_method :deq, :pop
-    alias_method :shift, :pop
-
-    # @!macro [attach] priority_queue_method_push
-    #  
-    #   Inserts the specified element into this priority queue.
-    #  
-    #   @param [Object] item the item to insert onto the queue
-    def push(item)
-      @length += 1
-      @queue << item
-      swim(@length)
-      true
-    end
-    alias_method :<<, :push
-    alias_method :enq, :push
-
-    # @!macro [attach] priority_queue_method_from_list
-    #  
-    #   Create a new priority queue from the given list.
-    #  
-    #   @param [Enumerable] list the list to build the queue from
-    #   @param [Hash] opts the options for creating the queue
-    #  
-    #   @return [PriorityQueue] the newly created and populated queue
-    def self.from_list(list, opts = {})
-      queue = new(opts)
-      list.each{|item| queue << item }
-      queue
-    end
-
-    protected
-
-    # Exchange the values at the given indexes within the internal array.
-    # 
-    # @param [Integer] x the first index to swap
-    # @param [Integer] y the second index to swap
-    # 
-    # @!visibility private
-    def swap(x, y)
-      temp = @queue[x]
-      @queue[x] = @queue[y]
-      @queue[y] = temp
-    end
-
-    # Are the items at the given indexes ordered based on the priority
-    # order specified at construction?
+    #   The JRuby native implementation is a thin wrapper around the standard
+    #   library `java.util.PriorityQueue`.
     #
-    # @param [Integer] x the first index from which to retrieve a comparable value
-    # @param [Integer] y the second index from which to retrieve a comparable value
+    #   When running under JRuby the class `PriorityQueue` extends `JavaPriorityQueue`.
+    #   When running under all other interpreters it extends `MutexPriorityQueue`.
     #
-    # @return [Boolean] true if the two elements are in the correct priority order
-    #   else false
-    # 
-    # @!visibility private
-    def ordered?(x, y)
-      (@queue[x] <=> @queue[y]) == @comparator
-    end
-
-    # Percolate down to maintain heap invariant.
-    # 
-    # @param [Integer] k the index at which to start the percolation
-    # 
-    # @!visibility private
-    def sink(k)
-      while (j = (2 * k)) <= @length do
-        j += 1 if j < @length && ! ordered?(j, j+1)
-        break if ordered?(k, j)
-        swap(k, j)
-        k = j
-      end
-    end
-
-    # Percolate up to maintain heap invariant.
-    # 
-    # @param [Integer] k the index at which to start the percolation
+    #   @note This implementation is *not* thread safe.
+    #
+    #   @see http://en.wikipedia.org/wiki/Priority_queue
+    #   @see http://ruby-doc.org/stdlib-2.0.0/libdoc/thread/rdoc/Queue.html
+    #
+    #   @see http://algs4.cs.princeton.edu/24pq/index.php#2.6
+    #   @see http://algs4.cs.princeton.edu/24pq/MaxPQ.java.html
+    #
+    #   @see http://docs.oracle.com/javase/7/docs/api/java/util/PriorityQueue.html
     # 
     # @!visibility private
-    def swim(k)
-      while k > 1 && ! ordered?(k/2, k) do
-        swap(k, k/2)
-        k = k/2
-      end
-    end
-  end
+    # @!macro internal_implementation_note
+    class MutexPriorityQueue
 
-  if RUBY_PLATFORM == 'java'
-
-    # @!macro priority_queue
-    class JavaPriorityQueue
-
-      # @!macro priority_queue_method_initialize
+      # @!macro [attach] priority_queue_method_initialize
+      #
+      #   Create a new priority queue with no items.
+      #  
+      #   @param [Hash] opts the options for creating the queue
+      #   @option opts [Symbol] :order (:max) dictates the order in which items are
+      #     stored: from highest to lowest when `:max` or `:high`; from lowest to
+      #     highest when `:min` or `:low`
       def initialize(opts = {})
         order = opts.fetch(:order, :max)
-        if [:min, :low].include?(order)
-          @queue = java.util.PriorityQueue.new(11) # 11 is the default initial capacity
-        else
-          @queue = java.util.PriorityQueue.new(11, java.util.Collections.reverseOrder())
-        end
+        @comparator = [:min, :low].include?(order) ? -1 : 1
+        clear
       end
 
-      # @!macro priority_queue_method_clear
+      # @!macro [attach] priority_queue_method_clear
+      #
+      #   Removes all of the elements from this priority queue.
       def clear
-        @queue.clear
+        @queue = [nil]
+        @length = 0
         true
       end
 
-      # @!macro priority_queue_method_delete
+      # @!macro [attach] priority_queue_method_delete
+      #
+      #   Deletes all items from `self` that are equal to `item`.
+      #  
+      #   @param [Object] item the item to be removed from the queue
+      #   @return [Object] true if the item is found else false
       def delete(item)
-        found = false
-        while @queue.remove(item) do
-          found = true
+        original_length = @length
+        k = 1
+        while k <= @length
+          if @queue[k] == item
+            swap(k, @length)
+            @length -= 1
+            sink(k)
+            @queue.pop
+          else
+            k += 1
+          end
         end
-        found
+        @length != original_length
       end
 
-      # @!macro priority_queue_method_empty
+      # @!macro [attach] priority_queue_method_empty
+      #  
+      #   Returns `true` if `self` contains no elements.
+      #  
+      #   @return [Boolean] true if there are no items in the queue else false
       def empty?
-        @queue.size == 0
+        size == 0
       end
 
-      # @!macro priority_queue_method_include
+      # @!macro [attach] priority_queue_method_include
+      #
+      #   Returns `true` if the given item is present in `self` (that is, if any
+      #   element == `item`), otherwise returns false.
+      #  
+      #   @param [Object] item the item to search for
+      #  
+      #   @return [Boolean] true if the item is found else false
       def include?(item)
-        @queue.contains(item)
+        @queue.include?(item)
       end
       alias_method :has_priority?, :include?
 
-      # @!macro priority_queue_method_length
+      # @!macro [attach] priority_queue_method_length
+      #  
+      #   The current length of the queue.
+      #  
+      #   @return [Fixnum] the number of items in the queue
       def length
-        @queue.size
+        @length
       end
       alias_method :size, :length
 
-      # @!macro priority_queue_method_peek
+      # @!macro [attach] priority_queue_method_peek
+      #  
+      #   Retrieves, but does not remove, the head of this queue, or returns `nil`
+      #   if this queue is empty.
+      #   
+      #   @return [Object] the head of the queue or `nil` when empty
       def peek
-        @queue.peek
+        @queue[1]
       end
 
-      # @!macro priority_queue_method_pop
+      # @!macro [attach] priority_queue_method_pop
+      #  
+      #   Retrieves and removes the head of this queue, or returns `nil` if this
+      #   queue is empty.
+      #   
+      #   @return [Object] the head of the queue or `nil` when empty
       def pop
-        @queue.poll
+        max = @queue[1]
+        swap(1, @length)
+        @length -= 1
+        sink(1)
+        @queue.pop
+        max
       end
       alias_method :deq, :pop
       alias_method :shift, :pop
 
-      # @!macro priority_queue_method_push
+      # @!macro [attach] priority_queue_method_push
+      #  
+      #   Inserts the specified element into this priority queue.
+      #  
+      #   @param [Object] item the item to insert onto the queue
       def push(item)
-        @queue.add(item)
+        @length += 1
+        @queue << item
+        swim(@length)
+        true
       end
       alias_method :<<, :push
       alias_method :enq, :push
 
-      # @!macro priority_queue_method_from_list
+      # @!macro [attach] priority_queue_method_from_list
+      #  
+      #   Create a new priority queue from the given list.
+      #  
+      #   @param [Enumerable] list the list to build the queue from
+      #   @param [Hash] opts the options for creating the queue
+      #  
+      #   @return [PriorityQueue] the newly created and populated queue
       def self.from_list(list, opts = {})
         queue = new(opts)
         list.each{|item| queue << item }
         queue
       end
+
+      protected
+
+      # Exchange the values at the given indexes within the internal array.
+      # 
+      # @param [Integer] x the first index to swap
+      # @param [Integer] y the second index to swap
+      # 
+      # @!visibility private
+      def swap(x, y)
+        temp = @queue[x]
+        @queue[x] = @queue[y]
+        @queue[y] = temp
+      end
+
+      # Are the items at the given indexes ordered based on the priority
+      # order specified at construction?
+      #
+      # @param [Integer] x the first index from which to retrieve a comparable value
+      # @param [Integer] y the second index from which to retrieve a comparable value
+      #
+      # @return [Boolean] true if the two elements are in the correct priority order
+      #   else false
+      # 
+      # @!visibility private
+      def ordered?(x, y)
+        (@queue[x] <=> @queue[y]) == @comparator
+      end
+
+      # Percolate down to maintain heap invariant.
+      # 
+      # @param [Integer] k the index at which to start the percolation
+      # 
+      # @!visibility private
+      def sink(k)
+        while (j = (2 * k)) <= @length do
+          j += 1 if j < @length && ! ordered?(j, j+1)
+          break if ordered?(k, j)
+          swap(k, j)
+          k = j
+        end
+      end
+
+      # Percolate up to maintain heap invariant.
+      # 
+      # @param [Integer] k the index at which to start the percolation
+      # 
+      # @!visibility private
+      def swim(k)
+        while k > 1 && ! ordered?(k/2, k) do
+          swap(k, k/2)
+          k = k/2
+        end
+      end
     end
 
-    # @!macro priority_queue
-    class PriorityQueue < JavaPriorityQueue
+    if Concurrent.on_jruby?
+
+      # @!macro priority_queue
+      # 
+      # @!visibility private
+      # @!macro internal_implementation_note
+      class JavaPriorityQueue
+
+        # @!macro priority_queue_method_initialize
+        def initialize(opts = {})
+          order = opts.fetch(:order, :max)
+          if [:min, :low].include?(order)
+            @queue = java.util.PriorityQueue.new(11) # 11 is the default initial capacity
+          else
+            @queue = java.util.PriorityQueue.new(11, java.util.Collections.reverseOrder())
+          end
+        end
+
+        # @!macro priority_queue_method_clear
+        def clear
+          @queue.clear
+          true
+        end
+
+        # @!macro priority_queue_method_delete
+        def delete(item)
+          found = false
+          while @queue.remove(item) do
+            found = true
+          end
+          found
+        end
+
+        # @!macro priority_queue_method_empty
+        def empty?
+          @queue.size == 0
+        end
+
+        # @!macro priority_queue_method_include
+        def include?(item)
+          @queue.contains(item)
+        end
+        alias_method :has_priority?, :include?
+
+        # @!macro priority_queue_method_length
+        def length
+          @queue.size
+        end
+        alias_method :size, :length
+
+        # @!macro priority_queue_method_peek
+        def peek
+          @queue.peek
+        end
+
+        # @!macro priority_queue_method_pop
+        def pop
+          @queue.poll
+        end
+        alias_method :deq, :pop
+        alias_method :shift, :pop
+
+        # @!macro priority_queue_method_push
+        def push(item)
+          @queue.add(item)
+        end
+        alias_method :<<, :push
+        alias_method :enq, :push
+
+        # @!macro priority_queue_method_from_list
+        def self.from_list(list, opts = {})
+          queue = new(opts)
+          list.each{|item| queue << item }
+          queue
+        end
+      end
     end
-  else
+
+    # @!visibility private
+    # @!macro internal_implementation_note
+    PriorityQueueImplementation = case
+                                  when Concurrent.on_jruby?
+                                    JavaPriorityQueue
+                                  else
+                                    MutexPriorityQueue
+                                  end
+    private_constant :PriorityQueueImplementation
 
     # @!macro priority_queue
-    class PriorityQueue < MutexPriorityQueue
+    # 
+    # @!visibility private
+    class PriorityQueue < PriorityQueueImplementation
+
+      alias_method :has_priority?, :include?
+
+      alias_method :size, :length
+
+      alias_method :deq, :pop
+      alias_method :shift, :pop
+
+      alias_method :<<, :push
+      alias_method :enq, :push
+
+      # @!method initialize(opts = {})
+      #   @!macro priority_queue_method_initialize
+
+      # @!method clear
+      #   @!macro priority_queue_method_clear
+
+      # @!method delete(item)
+      #   @!macro priority_queue_method_delete
+
+      # @!method empty?
+      #   @!macro priority_queue_method_empty
+
+      # @!method include?(item)
+      #   @!macro priority_queue_method_include
+
+      # @!method length
+      #   @!macro priority_queue_method_length
+
+      # @!method peek
+      #   @!macro priority_queue_method_peek
+
+      # @!method pop
+      #   @!macro priority_queue_method_pop
+
+      # @!method push(item)
+      #   @!macro priority_queue_method_push
+
+      # @!method self.from_list(list, opts = {})
+      #   @!macro priority_queue_method_from_list
     end
   end
 end