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

data/lib/concurrent/executor/java_cached_thread_pool.rb

@@ -1,32 +0,0 @@
-if RUBY_PLATFORM == 'java'
-
-  require 'concurrent/executor/java_thread_pool_executor'
-
-  module Concurrent
-
-    # @!macro cached_thread_pool
-    class JavaCachedThreadPool < JavaThreadPoolExecutor
-
-      # Create a new thread pool.
-      #
-      # @param [Hash] opts the options defining pool behavior.
-      # @option opts [Symbol] :fallback_policy (`:abort`) the fallback policy
-      #
-      # @raise [ArgumentError] if `fallback_policy` is not a known policy
-      #
-      # @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Executors.html#newCachedThreadPool--
-      def initialize(opts = {})
-        @fallback_policy = opts.fetch(:fallback_policy, opts.fetch(:overflow_policy, :abort))
-        warn '[DEPRECATED] :overflow_policy is deprecated terminology, please use :fallback_policy instead' if opts.has_key?(:overflow_policy)
-        @max_queue = 0
-
-        raise ArgumentError.new("#{@fallback_policy} is not a valid fallback policy") unless FALLBACK_POLICIES.keys.include?(@fallback_policy)
-
-        @executor = java.util.concurrent.Executors.newCachedThreadPool
-        @executor.setRejectedExecutionHandler(FALLBACK_POLICIES[@fallback_policy].new)
-
-        set_shutdown_hook
-      end
-    end
-  end
-end

data/lib/concurrent/executor/java_fixed_thread_pool.rb

@@ -1,31 +0,0 @@
-if RUBY_PLATFORM == 'java'
-
-  require 'concurrent/executor/java_thread_pool_executor'
-
-  module Concurrent
-
-    # @!macro fixed_thread_pool
-    class JavaFixedThreadPool < JavaThreadPoolExecutor
-
-      # Create a new thread pool.
-      #
-      # @param [Hash] opts the options defining pool behavior.
-      # @option opts [Symbol] :fallback_policy (`:abort`) the fallback policy
-      #
-      # @raise [ArgumentError] if `num_threads` is less than or equal to zero
-      # @raise [ArgumentError] if `fallback_policy` is not a known policy
-      #
-      # @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Executors.html#newFixedThreadPool-int-
-      def initialize(num_threads, opts = {})
-
-        opts = {
-            min_threads: num_threads,
-            max_threads: num_threads
-        }.merge(opts)
-        super(opts)
-
-        set_shutdown_hook
-      end
-    end
-  end
-end

data/lib/concurrent/executor/ruby_cached_thread_pool.rb

@@ -1,29 +0,0 @@
-require 'concurrent/executor/ruby_thread_pool_executor'
-
-module Concurrent
-
-  # @!macro cached_thread_pool
-  class RubyCachedThreadPool < RubyThreadPoolExecutor
-
-    # Create a new thread pool.
-    #
-    # @param [Hash] opts the options defining pool behavior.
-    # @option opts [Symbol] :fallback_policy (`:abort`) the fallback policy
-    #
-    # @raise [ArgumentError] if `fallback_policy` is not a known policy
-    def initialize(opts = {})
-      fallback_policy = opts.fetch(:fallback_policy, opts.fetch(:overflow_policy, :abort))
-
-      raise ArgumentError.new("#{fallback_policy} is not a valid fallback policy") unless FALLBACK_POLICIES.include?(fallback_policy)
-
-      opts = opts.merge(
-        min_threads: 0,
-        max_threads: DEFAULT_MAX_POOL_SIZE,
-        fallback_policy: fallback_policy,
-        max_queue: DEFAULT_MAX_QUEUE_SIZE,
-        idletime: DEFAULT_THREAD_IDLETIMEOUT
-      )
-      super(opts)
-    end
-  end
-end

data/lib/concurrent/executor/ruby_fixed_thread_pool.rb

@@ -1,32 +0,0 @@
-require 'concurrent/executor/ruby_thread_pool_executor'
-
-module Concurrent
-
-  # @!macro fixed_thread_pool
-  class RubyFixedThreadPool < RubyThreadPoolExecutor
-
-    # Create a new thread pool.
-    #
-    # @param [Integer] num_threads the number of threads to allocate
-    # @param [Hash] opts the options defining pool behavior.
-    # @option opts [Symbol] :fallback_policy (`:abort`) the fallback policy
-    #
-    # @raise [ArgumentError] if `num_threads` is less than or equal to zero
-    # @raise [ArgumentError] if `fallback_policy` is not a known policy
-    def initialize(num_threads, opts = {})
-      fallback_policy = opts.fetch(:fallback_policy, opts.fetch(:overflow_policy, :abort))
-
-      raise ArgumentError.new('number of threads must be greater than zero') if num_threads < 1
-      raise ArgumentError.new("#{fallback_policy} is not a valid fallback policy") unless FALLBACK_POLICIES.include?(fallback_policy)
-
-      opts = {
-        min_threads: num_threads,
-        max_threads: num_threads,
-        fallback_policy: fallback_policy,
-        max_queue: DEFAULT_MAX_QUEUE_SIZE,
-        idletime: DEFAULT_THREAD_IDLETIMEOUT,
-      }.merge(opts)
-      super(opts)
-    end
-  end
-end

data/lib/concurrent/executor/ruby_thread_pool_worker.rb

@@ -1,73 +0,0 @@
-require 'thread'
-require 'concurrent/logging'
-
-module Concurrent
-
-  # @!visibility private
-  class RubyThreadPoolWorker
-    include Logging
-
-    # @!visibility private
-    def initialize(queue, parent)
-      @queue = queue
-      @parent = parent
-      @mutex = Mutex.new
-      @last_activity = Time.now.to_f
-      @thread = nil
-    end
-
-    # @!visibility private
-    def dead?
-      return @mutex.synchronize do
-        @thread.nil? ? false : ! @thread.alive?
-      end
-    end
-
-    # @!visibility private
-    def last_activity
-      @mutex.synchronize { @last_activity }
-    end
-
-    def status
-      @mutex.synchronize do
-        return 'not running' if @thread.nil?
-        @thread.status
-      end
-    end
-
-    # @!visibility private
-    def kill
-      @mutex.synchronize do
-        Thread.kill(@thread) unless @thread.nil?
-        @thread = nil
-      end
-    end
-
-    # @!visibility private
-    def run(thread = Thread.current)
-      @mutex.synchronize do
-        raise StandardError.new('already running') unless @thread.nil?
-        @thread = thread
-      end
-
-      loop do
-        task = @queue.pop
-        if task == :stop
-          @thread = nil
-          @parent.on_worker_exit(self)
-          break
-        end
-
-        begin
-          task.last.call(*task.first)
-        rescue => ex
-          # let it fail
-          log DEBUG, ex
-        ensure
-          @last_activity = Time.now.to_f
-          @parent.on_end_task
-        end
-      end
-    end
-  end
-end

data/lib/concurrent/logging.rb

@@ -1,20 +0,0 @@
-require 'logger'
-
-module Concurrent
-  # Include where logging is needed
-  module Logging
-    include Logger::Severity
-
-    # Logs through {Configuration#logger}, it can be overridden by setting @logger
-    # @param [Integer] level one of Logger::Severity constants
-    # @param [String] progname e.g. a path of an Actor
-    # @param [String, nil] message when nil block is used to generate the message
-    # @yieldreturn [String] a message
-    def log(level, progname, message = nil, &block)
-      (@logger || Concurrent.configuration.logger).call level, progname, message, &block
-    rescue => error
-      $stderr.puts "`Concurrent.configuration.logger` failed to log #{[level, progname, message, block]}\n" +
-          "#{error.message} (#{error.class})\n#{error.backtrace.join "\n"}"
-    end
-  end
-end

data/lib/concurrent/obligation.rb

@@ -1,171 +0,0 @@
-require 'thread'
-require 'timeout'
-
-require 'concurrent/dereferenceable'
-require 'concurrent/atomic/event'
-
-module Concurrent
-
-  module Obligation
-    include Dereferenceable
-
-    # Has the obligation been fulfilled?
-    # @return [Boolean]
-    def fulfilled?
-      state == :fulfilled
-    end
-    alias_method :realized?, :fulfilled?
-
-    # Has the obligation been rejected?
-    # @return [Boolean]
-    def rejected?
-      state == :rejected
-    end
-
-    # Is obligation completion still pending?
-    # @return [Boolean]
-    def pending?
-      state == :pending
-    end
-
-    # Is the obligation still unscheduled?
-    # @return [Boolean]
-    def unscheduled?
-      state == :unscheduled
-    end
-
-    def completed?
-      [:fulfilled, :rejected].include? state
-    end
-
-    def incomplete?
-      [:unscheduled, :pending].include? state
-    end
-
-    # @return [Object] see Dereferenceable#deref
-    def value(timeout = nil)
-      wait timeout
-      deref
-    end
-
-    # wait until Obligation is #complete?
-    # @param [Numeric] timeout the maximum time in second to wait.
-    # @return [Obligation] self
-    def wait(timeout = nil)
-      event.wait(timeout) if timeout != 0 && incomplete?
-      self
-    end
-
-    # wait until Obligation is #complete?
-    # @param [Numeric] timeout the maximum time in second to wait.
-    # @return [Obligation] self
-    # @raise [Exception] when #rejected? it raises #reason
-    def no_error!(timeout = nil)
-      wait(timeout).tap { raise self if rejected? }
-    end
-
-    # @raise [Exception] when #rejected? it raises #reason
-    # @return [Object] see Dereferenceable#deref
-    def value!(timeout = nil)
-      wait(timeout)
-      if rejected?
-        raise self
-      else
-        deref
-      end
-    end
-
-    def state
-      mutex.lock
-      @state
-    ensure
-      mutex.unlock
-    end
-
-    def reason
-      mutex.lock
-      @reason
-    ensure
-      mutex.unlock
-    end
-
-    # @example allows Obligation to be risen
-    #   rejected_ivar = Ivar.new.fail
-    #   raise rejected_ivar
-    def exception(*args)
-      raise 'obligation is not rejected' unless rejected?
-      reason.exception(*args)
-    end
-
-    protected
-
-    # @!visibility private
-    def init_obligation # :nodoc:
-      init_mutex
-      @event = Event.new
-    end
-
-    # @!visibility private
-    def event # :nodoc:
-      @event
-    end
-
-    # @!visibility private
-    def set_state(success, value, reason) # :nodoc:
-      if success
-        @value = value
-        @state = :fulfilled
-      else
-        @reason = reason
-        @state  = :rejected
-      end
-    end
-
-    # @!visibility private
-    def state=(value) # :nodoc:
-      mutex.lock
-      @state = value
-    ensure
-      mutex.unlock
-    end
-
-    # atomic compare and set operation
-    # state is set to next_state only if current state is == expected_current
-    #
-    # @param [Symbol] next_state
-    # @param [Symbol] expected_current
-    # 
-    # @return [Boolean] true is state is changed, false otherwise
-    #
-    # @!visibility private
-    def compare_and_set_state(next_state, expected_current) # :nodoc:
-      mutex.lock
-      if @state == expected_current
-        @state = next_state
-        true
-      else
-        false
-      end
-    ensure
-      mutex.unlock
-    end
-
-    # executes the block within mutex if current state is included in expected_states
-    #
-    # @return block value if executed, false otherwise
-    #
-    # @!visibility private
-    def if_state(*expected_states) # :nodoc:
-      mutex.lock
-      raise ArgumentError.new('no block given') unless block_given?
-
-      if expected_states.include? @state
-        yield
-      else
-        false
-      end
-    ensure
-      mutex.unlock
-    end
-  end
-end

data/lib/concurrent/observable.rb

@@ -1,73 +0,0 @@
-require 'concurrent/atomic/copy_on_notify_observer_set'
-require 'concurrent/atomic/copy_on_write_observer_set'
-
-module Concurrent
-
-  # The [observer pattern](http://en.wikipedia.org/wiki/Observer_pattern) is one of the most useful design pattern.
-  # 
-  # The workflow is very simple:
-  # - an `observer` can register itself to a `subject` via a callback
-  # - many `observers` can be registered to the same `subject`
-  # - the `subject` notifies all registered observers when its status changes
-  # - an `observer` can deregister itself when is no more interested to receive event notifications
-  # 
-  # In a single threaded environment the whole pattern is very easy: the `subject` can use a simple data structure to manage all its subscribed `observer`s and every `observer` can react directly to every event without caring about synchronization.
-  # 
-  # In a multi threaded environment things are more complex.
-  # The `subject` must synchronize the access to its data structure and to do so currently we're using two specialized ObserverSet: CopyOnWriteObserverSet and CopyOnNotifyObserverSet.
-  # 
-  # When implementing and `observer` there's a very important rule to remember: **there are no guarantees about the thread that will execute the callback**
-  # 
-  # Let's take this example
-  # ```
-  # class Observer
-  #   def initialize
-  #     @count = 0
-  #   end
-  # 
-  #   def update
-  #     @count += 1
-  #   end
-  # end
-  # 
-  # obs = Observer.new
-  # [obj1, obj2, obj3, obj4].each { |o| o.add_observer(obs) }
-  # # execute [obj1, obj2, obj3, obj4]
-  # ```
-  # 
-  # `obs` is wrong because the variable `@count` can be accessed by different threads at the same time, so it should be synchronized (using either a Mutex or an AtomicFixum)
-  module Observable
-
-    # @return [Object] the added observer
-    def add_observer(*args, &block)
-      observers.add_observer(*args, &block)
-    end
-
-    # as #add_observer but it can be used for chaining
-    # @return [Observable] self
-    def with_observer(*args, &block)
-      add_observer(*args, &block)
-      self
-    end
-
-    # @return [Object] the deleted observer
-    def delete_observer(*args)
-      observers.delete_observer(*args)
-    end
-
-    # @return [Observable] self
-    def delete_observers
-      observers.delete_observers
-      self
-    end
-
-    # @return [Integer] the observers count
-    def count_observers
-      observers.count_observers
-    end
-
-    protected
-
-    attr_accessor :observers
-  end
-end