135 lines
5.6 KiB
Ruby
135 lines
5.6 KiB
Ruby
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
|