View file File name : concurrent.rb Content :require 'concurrent/version' require 'concurrent/constants' require 'concurrent/errors' require 'concurrent/configuration' require 'concurrent/atomics' require 'concurrent/executors' require 'concurrent/synchronization' require 'concurrent/atomic/atomic_markable_reference' require 'concurrent/atomic/atomic_reference' require 'concurrent/agent' require 'concurrent/atom' require 'concurrent/array' require 'concurrent/hash' require 'concurrent/set' require 'concurrent/map' require 'concurrent/tuple' require 'concurrent/async' require 'concurrent/dataflow' require 'concurrent/delay' require 'concurrent/exchanger' require 'concurrent/future' require 'concurrent/immutable_struct' require 'concurrent/ivar' require 'concurrent/maybe' require 'concurrent/mutable_struct' require 'concurrent/mvar' require 'concurrent/promise' require 'concurrent/scheduled_task' require 'concurrent/settable_struct' require 'concurrent/timer_task' require 'concurrent/tvar' require 'concurrent/promises' require 'concurrent/thread_safe/synchronized_delegator' require 'concurrent/thread_safe/util' require 'concurrent/options' # @!macro internal_implementation_note # # @note **Private Implementation:** This abstraction is a private, internal # implementation detail. It should never be used directly. # @!macro monotonic_clock_warning # # @note Time calculations on all platforms and languages are sensitive to # changes to the system clock. To alleviate the potential problems # associated with changing the system clock while an application is running, # most modern operating systems provide a monotonic clock that operates # independently of the system clock. A monotonic clock cannot be used to # determine human-friendly clock times. A monotonic clock is used exclusively # for calculating time intervals. Not all Ruby platforms provide access to an # operating system monotonic clock. On these platforms a pure-Ruby monotonic # clock will be used as a fallback. An operating system monotonic clock is both # faster and more reliable than the pure-Ruby implementation. The pure-Ruby # implementation should be fast and reliable enough for most non-realtime # operations. At this time the common Ruby platforms that provide access to an # operating system monotonic clock are MRI 2.1 and above and JRuby (all versions). # # @see http://linux.die.net/man/3/clock_gettime Linux clock_gettime(3) # @!macro copy_options # # ## Copy Options # # Object references in Ruby are mutable. This can lead to serious # problems when the {#value} of an object is a mutable reference. Which # is always the case unless the value is a `Fixnum`, `Symbol`, or similar # "primitive" data type. Each instance can be configured with a few # options that can help protect the program from potentially dangerous # operations. Each of these options can be optionally set when the object # instance is created: # # * `:dup_on_deref` When true the object will call the `#dup` method on # the `value` object every time the `#value` method is called # (default: false) # * `:freeze_on_deref` When true the object will call the `#freeze` # method on the `value` object every time the `#value` method is called # (default: false) # * `:copy_on_deref` When given a `Proc` object the `Proc` will be run # every time the `#value` method is called. The `Proc` will be given # the current `value` as its only argument and the result returned by # the block will be the return value of the `#value` call. When `nil` # this option will be ignored (default: nil) # # When multiple deref options are set the order of operations is strictly defined. # The order of deref operations is: # * `:copy_on_deref` # * `:dup_on_deref` # * `:freeze_on_deref` # # Because of this ordering there is no need to `#freeze` an object created by a # provided `:copy_on_deref` block. Simply set `:freeze_on_deref` to `true`. # Setting both `:dup_on_deref` to `true` and `:freeze_on_deref` to `true` is # as close to the behavior of a "pure" functional language (like Erlang, Clojure, # or Haskell) as we are likely to get in Ruby. # @!macro deref_options # # @option opts [Boolean] :dup_on_deref (false) Call `#dup` before # returning the data from {#value} # @option opts [Boolean] :freeze_on_deref (false) Call `#freeze` before # returning the data from {#value} # @option opts [Proc] :copy_on_deref (nil) When calling the {#value} # method, call the given proc passing the internal value as the sole # argument then return the new value returned from the proc. # @!macro executor_and_deref_options # # @param [Hash] opts the options used to define the behavior at update and deref # and to specify the executor on which to perform actions # @option opts [Executor] :executor when set use the given `Executor` instance. # Three special values are also supported: `:io` returns the global pool for # long, blocking (IO) tasks, `:fast` returns the global pool for short, fast # operations, and `:immediate` returns the global `ImmediateExecutor` object. # @!macro deref_options # @!macro warn.edge # @api Edge # @note **Edge Features** are under active development and may change frequently. # # - Deprecations are not added before incompatible changes. # - Edge version: _major_ is always 0, _minor_ bump means incompatible change, # _patch_ bump means compatible change. # - Edge features may also lack tests and documentation. # - Features developed in `concurrent-ruby-edge` are expected to move # to `concurrent-ruby` when finalised. # {include:file:README.md} module Concurrent end