Table of Contents - concurrent-ruby-1.1.4 Documentation
Pages
CHANGELOG
Current
Release v1.1.4 (14 Dec 2018)
Release v1.1.3 (7 Nov 2018)
Release v1.1.2 (6 Nov 2018)
Release v1.1.1, edge v0.4.1 (1 Nov 2018)
Release v1.1.0, edge v0.4.0 (31 OCt 2018) (yanked)
Release v1.1.0.pre2, edge v0.4.0.pre2 (18 Sep 2018)
Release v1.1.0.pre1, edge v0.4.0.pre1 (15 Aug 2018)
Release v1.0.5, edge v0.3.1 (26 Feb 2017)
Release v1.0.4, edge v0.3.0 (27 Dec 2016)
Release v1.0.3 (17 Dec 2016)
Release v1.0.2 (2 May 2016)
Release v1.0.1 (27 February 2016)
Release v1.0.0 (13 November 2015)
Release v0.9.1 (09 August 2015)
Release v0.9.0 (10 July 2015)
Release v0.8.0 (25 January 2015)
Release v0.7.2 (24 January 2015)
Release v0.7.1 (4 December 2014)
Release v0.7.0 (13 August 2014)
Release v0.6.1 (14 June 2014)
Release v0.6.0 (25 May 2014)
Release v0.5.0
LICENSE
README
Concurrent Ruby
Contributing
Thread Safety
Features & Documentation
Versioning
General-purpose Concurrency Abstractions
Thread-safe Value Objects, Structures, and Collections
Java-inspired ThreadPools and Other Executors
Thread Synchronization Classes and Algorithms
Deprecated
Edge Features
Supported Ruby versions
Usage
Installation
Edge Gem Installation
C Extensions for MRI
Note For gem developers
Maintainers
Special Thanks to
License and Copyright
Classes/Modules
Array
AtomicReference
Concurrent
Concurrent::AbstractExchanger
Concurrent::AbstractExecutorService
Concurrent::AbstractThreadLocalVar
Concurrent::Agent
Concurrent::Agent::Error
Concurrent::Agent::ValidationError
Concurrent::Async
Concurrent::Async::AsyncDelegator
Concurrent::Async::AwaitDelegator
Concurrent::Async::ClassMethods
Concurrent::AtExitImplementation
Concurrent::Atom
Concurrent::AtomicBoolean
Concurrent::AtomicDirectUpdate
Concurrent::AtomicFixnum
Concurrent::AtomicMarkableReference
Concurrent::AtomicNumericCompareAndSetWrapper
Concurrent::CachedThreadPool
Concurrent::Collection
Concurrent::Collection::AtomicReferenceMapBackend
Concurrent::Collection::AtomicReferenceMapBackend::Node
Concurrent::Collection::AtomicReferenceMapBackend::Table
Concurrent::Collection::CopyOnNotifyObserverSet
Concurrent::Collection::CopyOnWriteObserverSet
Concurrent::Collection::JavaNonConcurrentPriorityQueue
Concurrent::Collection::MriMapBackend
Concurrent::Collection::NonConcurrentMapBackend
Concurrent::Collection::NonConcurrentPriorityQueue
Concurrent::Collection::RubyNonConcurrentPriorityQueue
Concurrent::Collection::SynchronizedMapBackend
Concurrent::Concern
Concurrent::Concern::Deprecation
Concurrent::Concern::Dereferenceable
Concurrent::Concern::Logging
Concurrent::Concern::Obligation
Concurrent::Concern::Observable
Concurrent::ConcurrentUpdateError
Concurrent::CountDownLatch
Concurrent::CyclicBarrier
Concurrent::Delay
Concurrent::DependencyCounter
Concurrent::Event
Concurrent::Exchanger
Concurrent::ExecutorService
Concurrent::FixedThreadPool
Concurrent::Future
Concurrent::IVar
Concurrent::ImmediateExecutor
Concurrent::ImmutableStruct
Concurrent::IndirectImmediateExecutor
Concurrent::JavaAtomicReference
Concurrent::JavaCountDownLatch
Concurrent::JavaExchanger
Concurrent::JavaExecutorService
Concurrent::JavaExecutorService::Job
Concurrent::JavaSingleThreadExecutor
Concurrent::JavaThreadLocalVar
Concurrent::JavaThreadPoolExecutor
Concurrent::LockFreeStack
Concurrent::LockFreeStack::Node
Concurrent::MVar
Concurrent::Map
Concurrent::Maybe
Concurrent::MultipleAssignmentError
Concurrent::MultipleErrors
Concurrent::MutableStruct
Concurrent::MutexAtomicBoolean
Concurrent::MutexAtomicFixnum
Concurrent::MutexAtomicReference
Concurrent::MutexCountDownLatch
Concurrent::MutexSemaphore
Concurrent::Options
Concurrent::Process
Concurrent::Promise
Concurrent::Promises
Concurrent::Promises::AbstractAnyPromise
Concurrent::Promises::AbstractEventFuture
Concurrent::Promises::AbstractFlatPromise
Concurrent::Promises::AbstractPromise
Concurrent::Promises::AnyFulfilledFuturePromise
Concurrent::Promises::AnyResolvedEventPromise
Concurrent::Promises::AnyResolvedFuturePromise
Concurrent::Promises::BlockedPromise
Concurrent::Promises::BlockedTaskPromise
Concurrent::Promises::ChainPromise
Concurrent::Promises::DelayPromise
Concurrent::Promises::Event
Concurrent::Promises::EventWrapperPromise
Concurrent::Promises::FactoryMethods
Concurrent::Promises::FactoryMethods::Configuration
Concurrent::Promises::FlatEventPromise
Concurrent::Promises::FlatFuturePromise
Concurrent::Promises::Future
Concurrent::Promises::FutureWrapperPromise
Concurrent::Promises::ImmediateEventPromise
Concurrent::Promises::ImmediateFuturePromise
Concurrent::Promises::InnerPromise
Concurrent::Promises::InternalStates
Concurrent::Promises::InternalStates::Fulfilled
Concurrent::Promises::InternalStates::FulfilledArray
Concurrent::Promises::InternalStates::PartiallyRejected
Concurrent::Promises::InternalStates::Pending
Concurrent::Promises::InternalStates::Rejected
Concurrent::Promises::InternalStates::ResolvedWithResult
Concurrent::Promises::InternalStates::State
Concurrent::Promises::RescuePromise
Concurrent::Promises::Resolvable
Concurrent::Promises::ResolvableEvent
Concurrent::Promises::ResolvableEventPromise
Concurrent::Promises::ResolvableFuture
Concurrent::Promises::ResolvableFuturePromise
Concurrent::Promises::RunFuturePromise
Concurrent::Promises::ScheduledPromise
Concurrent::Promises::ThenPromise
Concurrent::Promises::ZipEventEventPromise
Concurrent::Promises::ZipEventsPromise
Concurrent::Promises::ZipFutureEventPromise
Concurrent::Promises::ZipFuturesPromise
Concurrent::RbxArray
Concurrent::RbxAtomicReference
Concurrent::RbxHash
Concurrent::RbxSet
Concurrent::ReInclude
Concurrent::ReadWriteLock
Concurrent::ReentrantReadWriteLock
Concurrent::RubyExchanger
Concurrent::RubyExchanger::Node
Concurrent::RubyExecutorService
Concurrent::RubySingleThreadExecutor
Concurrent::RubyThreadLocalVar
Concurrent::RubyThreadPoolExecutor
Concurrent::RubyThreadPoolExecutor::Worker
Concurrent::SafeTaskExecutor
Concurrent::ScheduledTask
Concurrent::Semaphore
Concurrent::SerialExecutorService
Concurrent::SerializedExecution
Concurrent::SerializedExecutionDelegator
Concurrent::SettableStruct
Concurrent::SimpleExecutorService
Concurrent::SingleThreadExecutor
Concurrent::Synchronization
Concurrent::Synchronization::AbstractLockableObject
Concurrent::Synchronization::AbstractObject
Concurrent::Synchronization::AbstractStruct
Concurrent::Synchronization::Condition
Concurrent::Synchronization::ConditionSignalling
Concurrent::Synchronization::JRubyAttrVolatile
Concurrent::Synchronization::JRubyAttrVolatile::ClassMethods
Concurrent::Synchronization::JRubyLockableObject
Concurrent::Synchronization::JRubyObject
Concurrent::Synchronization::Lock
Concurrent::Synchronization::LockableObject
Concurrent::Synchronization::MonitorLockableObject
Concurrent::Synchronization::MriAttrVolatile
Concurrent::Synchronization::MriAttrVolatile::ClassMethods
Concurrent::Synchronization::MriObject
Concurrent::Synchronization::MutexLockableObject
Concurrent::Synchronization::Object
Concurrent::Synchronization::RbxAttrVolatile
Concurrent::Synchronization::RbxAttrVolatile::ClassMethods
Concurrent::Synchronization::RbxLockableObject
Concurrent::Synchronization::RbxObject
Concurrent::Synchronization::TruffleRubyAttrVolatile
Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods
Concurrent::Synchronization::TruffleRubyObject
Concurrent::SynchronizedDelegator
Concurrent::TVar
Concurrent::ThreadLocalVar
Concurrent::ThreadPoolExecutor
Concurrent::ThreadSafe
Concurrent::ThreadSafe::Util
Concurrent::ThreadSafe::Util::Adder
Concurrent::ThreadSafe::Util::CheapLockable
Concurrent::ThreadSafe::Util::PowerOfTwoTuple
Concurrent::ThreadSafe::Util::Striped64
Concurrent::ThreadSafe::Util::Striped64::Cell
Concurrent::ThreadSafe::Util::Volatile
Concurrent::TimerSet
Concurrent::TimerTask
Concurrent::Transaction
Concurrent::TruffleRubyArray
Concurrent::TruffleRubyAtomicReference
Concurrent::TruffleRubyHash
Concurrent::TruffleRubySet
Concurrent::Tuple
Concurrent::Utility
Concurrent::Utility::EngineDetector
Concurrent::Utility::NativeExtensionLoader
Concurrent::Utility::NativeInteger
Concurrent::Utility::ProcessorCounter
Hash
Set
TruffleRuby
Methods
::<< — Concurrent::SimpleExecutorService
::abort_transaction — Concurrent
::add_delayed — Concurrent::Promises::BlockedPromise
::aggregate — Concurrent::Promise
::all? — Concurrent::Promise
::any? — Concurrent::Promise
::atomically — Concurrent
::attr_atomic — Concurrent::Synchronization::Object
::attr_volatile — Concurrent::Synchronization::AbstractObject
::await — Concurrent::Agent
::await_for — Concurrent::Agent
::await_for! — Concurrent::Agent
::call_dataflow — Concurrent
::create_simple_logger — Concurrent
::create_stdlib_logger — Concurrent
::current — Concurrent::Transaction
::current= — Concurrent::Transaction
::dataflow — Concurrent
::dataflow! — Concurrent
::dataflow_with — Concurrent
::dataflow_with! — Concurrent
::define_initialize_volatile_with_cas — Concurrent::Synchronization::Object
::define_struct_class — Concurrent::Synchronization::AbstractStruct
::disable_at_exit_handlers! — Concurrent
::ensure_safe_initialization_when_final_fields_are_present — Concurrent::Synchronization::Object
::execute — Concurrent::TimerTask
::execute — Concurrent::ScheduledTask
::execute — Concurrent::Future
::execute — Concurrent::Promise
::executor — Concurrent::Options
::executor — Concurrent
::from — Concurrent::Maybe
::from_list — Concurrent::Collection::RubyNonConcurrentPriorityQueue
::from_list — Concurrent::Collection::JavaNonConcurrentPriorityQueue
::fulfill — Concurrent::Promise
::global_fast_executor — Concurrent
::global_immediate_executor — Concurrent
::global_io_executor — Concurrent
::global_logger — Concurrent
::global_logger= — Concurrent
::global_timer_set — Concurrent
::included — Concurrent::Async
::included — Concurrent::Synchronization::TruffleRubyAttrVolatile
::included — Concurrent::Synchronization::RbxAttrVolatile
::included — Concurrent::Synchronization::MriAttrVolatile
::included — Concurrent::ImmutableStruct
::included — Concurrent::Synchronization::JRubyAttrVolatile
::just — Concurrent::Maybe
::leave_transaction — Concurrent
::locked_hash? — Concurrent::Collection::AtomicReferenceMapBackend::Node
::make_synchronized_on_rbx — Concurrent::ThreadSafe::Util
::make_synchronized_on_truffleruby — Concurrent::ThreadSafe::Util
::monotonic_time — Concurrent
::new — Concurrent::RubyExchanger
::new — Concurrent::AtomicMarkableReference
::new — Concurrent::Collection::AtomicReferenceMapBackend
::new — Concurrent::Collection::AtomicReferenceMapBackend::Node
::new — Concurrent::AbstractThreadLocalVar
::new — Concurrent
::new — Concurrent::Atom
::new — Concurrent::Async::AwaitDelegator
::new — Concurrent::Agent
::new — Concurrent::LockFreeStack
::new — Concurrent::Synchronization::AbstractStruct
::new — Concurrent::Collection::MriMapBackend
::new — Concurrent::Async::AsyncDelegator
::new — Concurrent::Utility::ProcessorCounter
::new — Concurrent::AtExitImplementation
::new — Concurrent::CyclicBarrier
::new — Concurrent::Agent::ValidationError
::new — Concurrent::Agent::Error
::new — Concurrent::Collection::NonConcurrentMapBackend
::new — Concurrent::Transaction
::new — Concurrent::TVar
::new — Concurrent::Tuple
::new — Concurrent::Collection::RubyNonConcurrentPriorityQueue
::new — Concurrent::TimerTask
::new — Concurrent::Event
::new — Concurrent::SettableStruct
::new — Concurrent::ThreadSafe::Util::Striped64
::new — Concurrent::ThreadSafe::Util::PowerOfTwoTuple
::new — Concurrent::SynchronizedDelegator
::new — Concurrent::Synchronization::TruffleRubyObject
::new — Concurrent::Synchronization::RbxObject
::new — Concurrent::Synchronization::RbxLockableObject
::new — Concurrent::JavaCountDownLatch
::new — Concurrent::Delay
::new — Concurrent::Collection::JavaNonConcurrentPriorityQueue
::new — Concurrent::MultipleAssignmentError
::new — Concurrent::ThreadSafe::Util
::new — Concurrent::MultipleErrors
::new — Concurrent::Synchronization::Object
::new — Concurrent::MutexAtomicBoolean
::new — Concurrent::AbstractExchanger
::new — Concurrent::Synchronization::Object
::new — Concurrent::Synchronization::MonitorLockableObject
::new — Concurrent::IVar
::new — Concurrent::Synchronization::MriObject
::new — Concurrent::Synchronization::JRubyObject
::new — Concurrent::Synchronization::Condition
::new — Concurrent::RubyExchanger::Node
::new — Concurrent::MutexAtomicFixnum
::new — Concurrent::Synchronization::AbstractObject
::new — Concurrent::JavaExchanger
::new — Concurrent::AbstractExecutorService
::new — Concurrent::ScheduledTask
::new — Concurrent::Promises::ScheduledPromise
::new — Concurrent::Promises::DelayPromise
::new — Concurrent::Promises::AnyResolvedEventPromise
::new — Concurrent::Promises::AnyResolvedFuturePromise
::new — Concurrent::Promises::ZipEventsPromise
::new — Concurrent::Promises::ZipFuturesPromise
::new — Concurrent::MutexCountDownLatch
::new — Concurrent::Promises::FutureWrapperPromise
::new — Concurrent::Promises::EventWrapperPromise
::new — Concurrent::Promises::ZipFutureEventPromise
::new — Concurrent::Promises::ZipEventEventPromise
::new — Concurrent::MutexSemaphore
::new — Concurrent::CachedThreadPool
::new — Concurrent::Promises::RunFuturePromise
::new — Concurrent::Promises::FlatFuturePromise
::new — Concurrent::Promises::FlatEventPromise
::new — Concurrent::Promises::AbstractFlatPromise
::new — Concurrent::Promises::ImmediateFuturePromise
::new — Concurrent::Promises::ImmediateEventPromise
::new — Concurrent::Promises::RescuePromise
::new — Concurrent::Promises::ThenPromise
::new — Concurrent::ReadWriteLock
::new — Concurrent::Promises::BlockedTaskPromise
::new — Concurrent::Promises::BlockedPromise
::new — Concurrent::FixedThreadPool
::new — Concurrent::ImmediateExecutor
::new — Concurrent::Collection::CopyOnWriteObserverSet
::new — Concurrent::IndirectImmediateExecutor
::new — Concurrent::JavaExecutorService
::new — Concurrent::Promises::BlockedPromise
::new — Concurrent::Promises::ResolvableFuturePromise
::new — Concurrent::Promises::ResolvableEventPromise
::new — Concurrent::Promises::AbstractPromise
::new — Concurrent::JavaExecutorService::Job
::new — Concurrent::JavaSingleThreadExecutor
::new — Concurrent::Promises::AbstractEventFuture
::new — Concurrent::Promises::InternalStates::PartiallyRejected
::new — Concurrent::ReentrantReadWriteLock
::new — Concurrent::Promises::InternalStates::Rejected
::new — Concurrent::Promises::InternalStates::Fulfilled
::new — Concurrent::LockFreeStack::Node
::new — Concurrent::ImmutableStruct
::new — Concurrent::JavaThreadPoolExecutor
::new — Concurrent::RubyExecutorService
::new — Concurrent::RubySingleThreadExecutor
::new — Concurrent::RubyThreadPoolExecutor
::new — Concurrent::RubyThreadPoolExecutor::Worker
::new — Concurrent::MutableStruct
::new — Concurrent::Promise
::new — Concurrent::MVar
::new — Concurrent::Maybe
::new — Concurrent::Collection::CopyOnNotifyObserverSet
::new — Concurrent::SafeTaskExecutor
::new — Concurrent::SerializedExecution
::new — Concurrent::SerializedExecutionDelegator
::new — Concurrent::TimerSet
::new — Concurrent::MutexAtomicReference
::new — Concurrent::Future
::new — Concurrent::Map
::new — Concurrent::Synchronization::MutexLockableObject
::new_blocked_by — Concurrent::Promises::BlockedPromise
::new_blocked_by1 — Concurrent::Promises::BlockedPromise
::new_blocked_by2 — Concurrent::Promises::BlockedPromise
::new_fast_executor — Concurrent
::new_io_executor — Concurrent
::nothing — Concurrent::Maybe
::of1 — Concurrent::LockFreeStack
::of2 — Concurrent::LockFreeStack
::padding — Concurrent::ThreadSafe::Util::Striped64::Cell
::physical_processor_count — Concurrent
::post — Concurrent::SimpleExecutorService
::processor_count — Concurrent
::reject — Concurrent::Promise
::safe_initialization! — Concurrent::Synchronization::Object
::safe_initialization? — Concurrent::Synchronization::Object
::synchronized — TruffleRuby
::thread_finalizer — Concurrent::RubyThreadLocalVar
::threadlocal_finalizer — Concurrent::RubyThreadLocalVar
::use_simple_logger — Concurrent
::use_stdlib_logger — Concurrent
::validate_argc — Concurrent::Async
::volatile_cas_fields — Concurrent::Synchronization::Object
::zip — Concurrent::Promise
#& — Concurrent::Promises::Event
#& — Concurrent::Promises::Future
#<< — Concurrent::SimpleExecutorService
#<< — Concurrent::Collection::JavaNonConcurrentPriorityQueue
#<< — Concurrent::Collection::RubyNonConcurrentPriorityQueue
#<< — Concurrent::RubyThreadPoolExecutor::Worker
#<< — Concurrent::Agent
#<< — Concurrent::ImmediateExecutor
#<< — Concurrent::ExecutorService
#<=> — Concurrent::Maybe
#<=> — Concurrent::ScheduledTask
#== — Concurrent::MutableStruct
#== — Concurrent::SettableStruct
#== — Concurrent::ImmutableStruct
#[] — Concurrent::SettableStruct
#[] — Concurrent::MutableStruct
#[] — Concurrent::Map
#[] — Concurrent::Collection::SynchronizedMapBackend
#[] — Concurrent::Collection::AtomicReferenceMapBackend
#[] — Concurrent::Collection::NonConcurrentMapBackend
#[] — Concurrent::ImmutableStruct
#[]= — Concurrent::Collection::NonConcurrentMapBackend
#[]= — Concurrent::SettableStruct
#[]= — Concurrent::Collection::MriMapBackend
#[]= — Concurrent::Collection::AtomicReferenceMapBackend
#[]= — Concurrent::MutableStruct
#[]= — Concurrent::Collection::SynchronizedMapBackend
#_compare_and_set — Concurrent::MutexAtomicReference
#_get — Concurrent::Collection::NonConcurrentMapBackend
#_mon_initialize — Concurrent::ThreadSafe::Util
#_set — Concurrent::Collection::NonConcurrentMapBackend
#abort — Concurrent::Transaction
#abort_transaction — Concurrent
#acquire — Concurrent::MutexSemaphore
#acquire_read_lock — Concurrent::ReadWriteLock
#acquire_read_lock — Concurrent::ReentrantReadWriteLock
#acquire_write_lock — Concurrent::ReadWriteLock
#acquire_write_lock — Concurrent::ReentrantReadWriteLock
#add — Concurrent::AtExitImplementation
#add — Concurrent::ThreadSafe::Util::Adder
#add_callback — Concurrent::Promises::AbstractEventFuture
#add_callback_clear_delayed_node — Concurrent::Promises::AbstractEventFuture
#add_callback_notify_blocked — Concurrent::Promises::AbstractEventFuture
#add_delayed_of — Concurrent::Promises::AbstractFlatPromise
#add_observer — Concurrent::IVar
#add_observer — Concurrent::Collection::CopyOnNotifyObserverSet
#add_observer — Concurrent::Collection::CopyOnWriteObserverSet
#add_observer — Concurrent::Concern::Observable
#allocate_storage — Concurrent::JavaThreadLocalVar
#allocate_storage — Concurrent::AbstractThreadLocalVar
#allocate_storage — Concurrent::RubyThreadLocalVar
#allow_c_extensions? — Concurrent::Utility::NativeExtensionLoader
#any — Concurrent::Promises::Event
#any — Concurrent::Promises::FactoryMethods
#any — Concurrent::Promises::Future
#any_event — Concurrent::Promises::FactoryMethods
#any_event_on — Concurrent::Promises::FactoryMethods
#any_fulfilled_future — Concurrent::Promises::FactoryMethods
#any_fulfilled_future_on — Concurrent::Promises::FactoryMethods
#any_resolved_future — Concurrent::Promises::FactoryMethods
#any_resolved_future_on — Concurrent::Promises::FactoryMethods
#apply — Concurrent::Promises::InternalStates::Rejected
#apply — Concurrent::Promises::InternalStates::FulfilledArray
#apply — Concurrent::Promises::InternalStates::PartiallyRejected
#apply — Concurrent::Promises::InternalStates::ResolvedWithResult
#apply — Concurrent::Promises::Future
#apply — Concurrent::Promises::InternalStates::Fulfilled
#apply_deref_options — Concurrent::Concern::Dereferenceable
#async — Concurrent::Async
#async_callback_on_fulfillment — Concurrent::Promises::Future
#async_callback_on_rejection — Concurrent::Promises::Future
#async_callback_on_resolution — Concurrent::Promises::AbstractEventFuture
#atomically — Concurrent
#attempt_compute — Concurrent::Collection::AtomicReferenceMapBackend
#attempt_get_and_set — Concurrent::Collection::AtomicReferenceMapBackend
#attempt_internal_compute_if_absent — Concurrent::Collection::AtomicReferenceMapBackend
#attempt_internal_replace — Concurrent::Collection::AtomicReferenceMapBackend
#attr_volatile — Concurrent::ThreadSafe::Util::Volatile
#attr_volatile — Concurrent::Synchronization::MriAttrVolatile::ClassMethods
#attr_volatile — Concurrent::Synchronization::JRubyAttrVolatile::ClassMethods
#attr_volatile — Concurrent::Synchronization::RbxAttrVolatile::ClassMethods
#attr_volatile — Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods
#auto_terminate= — Concurrent::AbstractExecutorService
#auto_terminate? — Concurrent::AbstractExecutorService
#available_permits — Concurrent::MutexSemaphore
#await — Concurrent::Agent
#await — Concurrent::Async
#await_for — Concurrent::Agent
#await_for! — Concurrent::Agent
#bind — Concurrent::AbstractThreadLocalVar
#blocked_by — Concurrent::Promises::BlockedPromise
#blocks — Concurrent::Promises::AbstractEventFuture
#borrow — Concurrent::MVar
#broadcast — Concurrent::Synchronization::Condition
#broadcast — Concurrent::Synchronization::Lock
#broken? — Concurrent::CyclicBarrier
#c_extensions_loaded? — Concurrent::Utility::NativeExtensionLoader
#call — Concurrent::Async
#call_callback — Concurrent::Promises::AbstractEventFuture
#call_callbacks — Concurrent::Promises::AbstractEventFuture
#call_dataflow — Concurrent
#call_job — Concurrent::SerializedExecution
#callback_clear_delayed_node — Concurrent::Promises::AbstractEventFuture
#callback_notify_blocked — Concurrent::Promises::AbstractEventFuture
#callback_on_fulfillment — Concurrent::Promises::Future
#callback_on_rejection — Concurrent::Promises::Future
#callback_on_resolution — Concurrent::Promises::Future
#callback_on_resolution — Concurrent::Promises::Event
#callbacks — Concurrent::Promises::AbstractEventFuture
#can_overflow? — Concurrent::ExecutorService
#can_overflow? — Concurrent::RubyThreadPoolExecutor
#can_overflow? — Concurrent::JavaThreadPoolExecutor
#cancel — Concurrent::Future
#cancel — Concurrent::ScheduledTask
#cancelled? — Concurrent::Future
#cancelled? — Concurrent::ScheduledTask
#cas — Concurrent::Tuple
#cas_base_computed — Concurrent::ThreadSafe::Util::Striped64
#cas_computed — Concurrent::ThreadSafe::Util::Striped64::Cell
#cas_new_node — Concurrent::Collection::AtomicReferenceMapBackend::Table
#cast — Concurrent::Async
#catch — Concurrent::Promise
#chain — Concurrent::Promises::AbstractEventFuture
#chain_on — Concurrent::Promises::AbstractEventFuture
#chain_resolvable — Concurrent::Promises::AbstractEventFuture
#cheap_broadcast — Concurrent::ThreadSafe::Util::CheapLockable
#cheap_synchronize — Concurrent::ThreadSafe::Util::CheapLockable
#cheap_wait — Concurrent::ThreadSafe::Util::CheapLockable
#check_for_resize — Concurrent::Collection::AtomicReferenceMapBackend
#clear — Concurrent::Collection::RubyNonConcurrentPriorityQueue
#clear — Concurrent::LockFreeStack
#clear — Concurrent::Collection::NonConcurrentMapBackend
#clear — Concurrent::Collection::SynchronizedMapBackend
#clear — Concurrent::Collection::JavaNonConcurrentPriorityQueue
#clear — Concurrent::Collection::MriMapBackend
#clear — Concurrent::Collection::AtomicReferenceMapBackend
#clear_and_propagate_touch — Concurrent::Promises::BlockedPromise
#clear_each — Concurrent::LockFreeStack
#clear_if — Concurrent::LockFreeStack
#clear_observers_and_return_old — Concurrent::Collection::CopyOnWriteObserverSet
#commit — Concurrent::Transaction
#compare_and_clear — Concurrent::LockFreeStack
#compare_and_pop — Concurrent::LockFreeStack
#compare_and_push — Concurrent::LockFreeStack
#compare_and_set — Concurrent::AtomicNumericCompareAndSetWrapper
#compare_and_set — Concurrent::Tuple
#compare_and_set — Concurrent::AtomicMarkableReference
#compare_and_set — Concurrent::MutexAtomicFixnum
#compare_and_set — Concurrent::Atom
#compare_and_set_state — Concurrent::Concern::Obligation
#compare_and_swap — Concurrent::AtomicMarkableReference
#complete — Concurrent::Promise
#complete — Concurrent::IVar
#complete? — Concurrent::Concern::Obligation
#complete_without_notification — Concurrent::IVar
#completed_task_count — Concurrent::RubyThreadPoolExecutor
#completed_task_count — Concurrent::JavaThreadPoolExecutor
#compute — Concurrent::Collection::SynchronizedMapBackend
#compute — Concurrent::Collection::NonConcurrentMapBackend
#compute — Concurrent::Collection::AtomicReferenceMapBackend
#compute — Concurrent::Collection::MriMapBackend
#compute_if_absent — Concurrent::Collection::SynchronizedMapBackend
#compute_if_absent — Concurrent::Collection::NonConcurrentMapBackend
#compute_if_absent — Concurrent::Collection::AtomicReferenceMapBackend
#compute_if_absent — Concurrent::Collection::MriMapBackend
#compute_if_present — Concurrent::Collection::NonConcurrentMapBackend
#compute_if_present — Concurrent::Collection::SynchronizedMapBackend
#compute_if_present — Concurrent::Collection::MriMapBackend
#compute_if_present — Concurrent::Collection::AtomicReferenceMapBackend
#compute_physical_processor_count — Concurrent::Utility::ProcessorCounter
#compute_processor_count — Concurrent::Utility::ProcessorCounter
#count — Concurrent::JavaCountDownLatch
#count — Concurrent::MutexCountDownLatch
#count_down — Concurrent::MutexCountDownLatch
#count_down — Concurrent::JavaCountDownLatch
#count_observers — Concurrent::Concern::Observable
#count_observers — Concurrent::Collection::CopyOnNotifyObserverSet
#count_observers — Concurrent::Collection::CopyOnWriteObserverSet
#create_worker — Concurrent::RubyThreadPoolExecutor::Worker
#dataflow — Concurrent
#dataflow! — Concurrent
#dataflow_with — Concurrent
#dataflow_with! — Concurrent
#decrement — Concurrent::MutexAtomicFixnum
#decrement — Concurrent::ThreadSafe::Util::Adder
#decrement_size — Concurrent::Collection
#default — Concurrent::AbstractThreadLocalVar
#default_executor — Concurrent::Promises::AbstractPromise
#default_executor — Concurrent::Promises::AbstractEventFuture
#default_executor — Concurrent::Promises::FactoryMethods::Configuration
#default_for — Concurrent::RubyThreadLocalVar
#delay — Concurrent::Promises::FactoryMethods
#delay — Concurrent::Promises::Event
#delay — Concurrent::Promises::Future
#delay_on — Concurrent::Promises::FactoryMethods
#delayed_because — Concurrent::Promises::DelayPromise
#delayed_because — Concurrent::Promises::BlockedPromise
#delayed_because — Concurrent::Promises::AbstractPromise
#delete — Concurrent::Collection::SynchronizedMapBackend
#delete — Concurrent::Collection::JavaNonConcurrentPriorityQueue
#delete — Concurrent::Collection::NonConcurrentMapBackend
#delete — Concurrent::Collection::RubyNonConcurrentPriorityQueue
#delete — Concurrent::Collection::MriMapBackend
#delete — Concurrent::Collection::AtomicReferenceMapBackend
#delete — Concurrent::AtExitImplementation
#delete_node_at — Concurrent::Collection::AtomicReferenceMapBackend::Table
#delete_observer — Concurrent::Collection::CopyOnNotifyObserverSet
#delete_observer — Concurrent::Collection::CopyOnWriteObserverSet
#delete_observer — Concurrent::Concern::Observable
#delete_observers — Concurrent::Collection::CopyOnNotifyObserverSet
#delete_observers — Concurrent::Collection::CopyOnWriteObserverSet
#delete_observers — Concurrent::Concern::Observable
#delete_pair — Concurrent::Collection::AtomicReferenceMapBackend
#delete_pair — Concurrent::Collection::NonConcurrentMapBackend
#delete_pair — Concurrent::Collection::SynchronizedMapBackend
#delete_pair — Concurrent::Collection::MriMapBackend
#deprecated — Concurrent::Concern::Deprecation
#deprecated_method — Concurrent::Concern::Deprecation
#deq — Concurrent::Collection::JavaNonConcurrentPriorityQueue
#deq — Concurrent::Collection::RubyNonConcurrentPriorityQueue
#deref — Concurrent::Concern::Dereferenceable
#deref — Concurrent::Agent
#do_exchange — Concurrent::AbstractExchanger
#do_exchange — Concurrent::JavaExchanger
#do_exchange — Concurrent::RubyExchanger
#down — Concurrent::MutexAtomicFixnum
#drain_permits — Concurrent::MutexSemaphore
#duplicate_and_clear_observers — Concurrent::Collection::CopyOnNotifyObserverSet
#duplicate_observers — Concurrent::Collection::CopyOnNotifyObserverSet
#dupped_backend — Concurrent::Collection::NonConcurrentMapBackend
#dupped_backend — Concurrent::Collection::SynchronizedMapBackend
#each — Concurrent::Tuple
#each — Concurrent::Map
#each — Concurrent::ImmutableStruct
#each — Concurrent::LockFreeStack
#each — Concurrent::SettableStruct
#each — Concurrent::MutableStruct
#each_key — Concurrent::Map
#each_pair — Concurrent::MutableStruct
#each_pair — Concurrent::Collection::AtomicReferenceMapBackend
#each_pair — Concurrent::SettableStruct
#each_pair — Concurrent::ImmutableStruct
#each_pair — Concurrent::Collection::NonConcurrentMapBackend
#each_pair — Concurrent::Map
#each_value — Concurrent::Map
#empty? — Concurrent::Collection::JavaNonConcurrentPriorityQueue
#empty? — Concurrent::Map
#empty? — Concurrent::Collection::AtomicReferenceMapBackend
#empty? — Concurrent::Collection::RubyNonConcurrentPriorityQueue
#empty? — Concurrent::LockFreeStack
#empty? — Concurrent::MVar
#enabled= — Concurrent::AtExitImplementation
#enabled? — Concurrent::AtExitImplementation
#enq — Concurrent::Collection::JavaNonConcurrentPriorityQueue
#enq — Concurrent::Collection::RubyNonConcurrentPriorityQueue
#enqueue_action_job — Concurrent::Agent
#enqueue_await_job — Concurrent::Agent
#ensure_integer — Concurrent::Utility::NativeInteger
#ensure_integer_and_bounds — Concurrent::Utility::NativeInteger
#ensure_lower_bound — Concurrent::Utility::NativeInteger
#ensure_positive — Concurrent::Utility::NativeInteger
#ensure_positive_and_no_zero — Concurrent::Utility::NativeInteger
#ensure_upper_bound — Concurrent::Utility::NativeInteger
#error — Concurrent::Agent
#evaluate_to — Concurrent::Promises::AbstractPromise
#evaluate_to — Concurrent::Promises::ResolvableFuture
#evaluate_to! — Concurrent::Promises::ResolvableFuture
#event — Concurrent::Concern::Obligation
#event — Concurrent::Promises::AbstractPromise
#exception — Concurrent::Concern::Obligation
#exception — Concurrent::Promises::Future
#exchange — Concurrent::AbstractExchanger
#exchange! — Concurrent::AbstractExchanger
#execute — Concurrent::TimerTask
#execute — Concurrent::Future
#execute — Concurrent::ScheduledTask
#execute — Concurrent::Promise
#execute — Concurrent::SafeTaskExecutor
#execute_next_job — Concurrent::Agent
#execute_task — Concurrent::TimerTask
#execution_interval — Concurrent::TimerTask
#execution_interval= — Concurrent::TimerTask
#executor — Concurrent::Promises::BlockedTaskPromise
#expand_table_unless_stale — Concurrent::ThreadSafe::Util::Striped64
#extended — Concurrent::ReInclude
#fail — Concurrent::IVar
#fail — Concurrent::Promise
#failed? — Concurrent::Agent
#false? — Concurrent::MutexAtomicBoolean
#fetch — Concurrent::Map
#fetch_or_store — Concurrent::Map
#find_value_in_node_list — Concurrent::Collection::AtomicReferenceMapBackend
#flat — Concurrent::Promises::Future
#flat_event — Concurrent::Promises::Future
#flat_future — Concurrent::Promises::Future
#flat_map — Concurrent::Promise
#force_acquire_lock — Concurrent::Collection::AtomicReferenceMapBackend::Node
#free? — Concurrent::ThreadSafe::Util::Striped64
#fulfill — Concurrent::Promises::ResolvableFuturePromise
#fulfill — Concurrent::Promises::ResolvableFuture
#fulfilled? — Concurrent::Concern::Obligation
#fulfilled? — Concurrent::Maybe
#fulfilled? — Concurrent::Promises::InternalStates::Rejected
#fulfilled? — Concurrent::Promises::Future
#fulfilled? — Concurrent::Promises::InternalStates::PartiallyRejected
#fulfilled? — Concurrent::Promises::InternalStates::Fulfilled
#fulfilled? — Concurrent::Promises::InternalStates::ResolvedWithResult
#fulfilled_future — Concurrent::Promises::FactoryMethods
#full? — Concurrent::MVar
#full_memory_barrier — Concurrent::Synchronization::AbstractObject
#full_memory_barrier — Concurrent::Synchronization::TruffleRubyAttrVolatile
#full_memory_barrier — Concurrent::Synchronization::MriAttrVolatile
#full_memory_barrier — Concurrent::Synchronization::RbxAttrVolatile
#future — Concurrent::Promises::AbstractPromise
#future — Concurrent::Promises::FactoryMethods
#future_on — Concurrent::Promises::FactoryMethods
#get — Concurrent::Tuple
#get — Concurrent::MutexAtomicReference
#get — Concurrent::Map
#get — Concurrent::AtomicMarkableReference
#get_and_set — Concurrent::Collection::SynchronizedMapBackend
#get_and_set — Concurrent::Collection::NonConcurrentMapBackend
#get_and_set — Concurrent::Collection::AtomicReferenceMapBackend
#get_and_set — Concurrent::MutexAtomicReference
#get_and_set — Concurrent::Collection::MriMapBackend
#get_arguments_from — Concurrent::Concern::Obligation
#get_or_default — Concurrent::Collection::NonConcurrentMapBackend
#get_or_default — Concurrent::Collection::SynchronizedMapBackend
#get_or_default — Concurrent::Collection::AtomicReferenceMapBackend
#get_threadlocal_array — Concurrent::RubyThreadLocalVar
#get_time — Concurrent
#handle_error — Concurrent::Agent
#handle_fallback — Concurrent::AbstractExecutorService
#handler? — Concurrent::AtExitImplementation
#handlers — Concurrent::AtExitImplementation
#has_priority? — Concurrent::Collection::RubyNonConcurrentPriorityQueue
#has_priority? — Concurrent::Collection::JavaNonConcurrentPriorityQueue
#has_waiters? — Concurrent::ReadWriteLock
#hash_code — Concurrent::ThreadSafe::Util::Striped64
#hash_code= — Concurrent::ThreadSafe::Util::Striped64
#hash_to_index — Concurrent::ThreadSafe::Util::PowerOfTwoTuple
#idletime — Concurrent::JavaThreadPoolExecutor
#if_state — Concurrent::Concern::Obligation
#immutable_array — Concurrent::AtomicMarkableReference
#include — Concurrent::ReInclude
#include? — Concurrent::Collection::JavaNonConcurrentPriorityQueue
#include? — Concurrent::Collection::RubyNonConcurrentPriorityQueue
#included — Concurrent::ReInclude
#incomplete? — Concurrent::Concern::Obligation
#increment — Concurrent::MutexAtomicFixnum
#increment — Concurrent::ThreadSafe::Util::Adder
#increment_size — Concurrent::Collection
#index — Concurrent::Map
#init_obligation — Concurrent::Concern::Obligation
#init_synchronization — Concurrent::Async
#initial_delay — Concurrent::ScheduledTask
#initialize_copy — Concurrent::Collection::AtomicReferenceMapBackend
#initialize_copy — Concurrent::Collection::NonConcurrentMapBackend
#initialize_copy — Concurrent::Map
#initialize_table — Concurrent::Collection::AtomicReferenceMapBackend
#initialize_volatile_with_cas — Concurrent::Synchronization::Object
#inspect — Concurrent::AtomicFixnum
#inspect — AtomicReference
#inspect — Concurrent::SettableStruct
#inspect — Concurrent::MutableStruct
#inspect — Concurrent::MultipleAssignmentError
#inspect — Concurrent::ImmutableStruct
#inspect — Concurrent::AtomicBoolean
#inspect — Concurrent::LockFreeStack
#inspect — Concurrent::Promises::AbstractPromise
#inspect — Concurrent::Promises::AbstractEventFuture
#inspect — Concurrent::Map
#inspect — Concurrent::Promises::ScheduledPromise
#install — Concurrent::AtExitImplementation
#intended_time — Concurrent::Promises::ScheduledPromise
#internal_compute — Concurrent::Collection::AtomicReferenceMapBackend
#internal_replace — Concurrent::Collection::AtomicReferenceMapBackend
#internal_reset — Concurrent::ThreadSafe::Util::Striped64
#item — Concurrent::RubyExchanger::Node
#java_extensions_loaded? — Concurrent::Utility::NativeExtensionLoader
#just? — Concurrent::Maybe
#key — Concurrent::Map
#key? — Concurrent::Collection::NonConcurrentMapBackend
#key? — Concurrent::Collection::SynchronizedMapBackend
#key? — Concurrent::Collection::AtomicReferenceMapBackend::Node
#key? — Concurrent::Collection::AtomicReferenceMapBackend
#key_hash — Concurrent::Collection::AtomicReferenceMapBackend
#keys — Concurrent::Map
#kill — Concurrent::TimerSet
#kill — Concurrent::JavaExecutorService
#kill — Concurrent::AbstractExecutorService
#kill — Concurrent::ImmediateExecutor
#kill — Concurrent::RubyExecutorService
#kill — Concurrent::SimpleExecutorService
#kill — Concurrent::RubyThreadPoolExecutor::Worker
#largest_length — Concurrent::RubyThreadPoolExecutor
#largest_length — Concurrent::JavaThreadPoolExecutor
#latch — Concurrent::RubyExchanger::Node
#leave_transaction — Concurrent
#length — Concurrent::Collection::RubyNonConcurrentPriorityQueue
#length — Concurrent::JavaThreadPoolExecutor
#length — Concurrent::RubyThreadPoolExecutor
#length — Concurrent::Collection::JavaNonConcurrentPriorityQueue
#length — Concurrent::Synchronization::AbstractStruct
#load_error_path — Concurrent::Utility::NativeExtensionLoader
#load_native_extensions — Concurrent::Utility::NativeExtensionLoader
#lock_and_clean_up_reverse_forwarders — Concurrent::Collection
#locked? — Concurrent::Collection::AtomicReferenceMapBackend::Node
#log — Concurrent::Concern::Logging
#make_false — Concurrent::MutexAtomicBoolean
#make_future — Concurrent::Promises::FactoryMethods
#make_true — Concurrent::MutexAtomicBoolean
#mark — Concurrent::AtomicMarkableReference
#marked? — Concurrent::AtomicMarkableReference
#marshal_dump — Concurrent::Map
#marshal_load — Concurrent::Map
#matches? — Concurrent::Collection::AtomicReferenceMapBackend::Node
#max_readers? — Concurrent::ReentrantReadWriteLock
#max_readers? — Concurrent::ReadWriteLock
#max_writers? — Concurrent::ReadWriteLock
#max_writers? — Concurrent::ReentrantReadWriteLock
#members — Concurrent::Synchronization::AbstractStruct
#merge — Concurrent::MutableStruct
#merge — Concurrent::ImmutableStruct
#merge — Concurrent::SettableStruct
#merge_pair — Concurrent::Collection::AtomicReferenceMapBackend
#merge_pair — Concurrent::Collection::MriMapBackend
#merge_pair — Concurrent::Collection::NonConcurrentMapBackend
#merge_pair — Concurrent::Collection::SynchronizedMapBackend
#method_missing — Concurrent::SynchronizedDelegator
#method_missing — Concurrent::Async::AsyncDelegator
#method_missing — Concurrent::Async::AwaitDelegator
#min_length — Concurrent::JavaThreadPoolExecutor
#modify — Concurrent::MVar
#modify! — Concurrent::MVar
#monotonic_time — Concurrent
#new — Concurrent::Async::ClassMethods
#new_condition — Concurrent::Synchronization::LockableObject
#next_in_size_table — Concurrent::ThreadSafe::Util::PowerOfTwoTuple
#no_error! — Concurrent::Concern::Obligation
#nothing? — Concurrent::Maybe
#notify_and_delete_observers — Concurrent::Collection::CopyOnWriteObserverSet
#notify_and_delete_observers — Concurrent::Collection::CopyOnNotifyObserverSet
#notify_child — Concurrent::Promise
#notify_observers — Concurrent::Collection::CopyOnWriteObserverSet
#notify_observers — Concurrent::Collection::CopyOnNotifyObserverSet
#notify_observers — Concurrent::IVar
#notify_to — Concurrent::Collection::CopyOnWriteObserverSet
#notify_to — Concurrent::Collection::CopyOnNotifyObserverSet
#ns_add_busy_worker — Concurrent::RubyThreadPoolExecutor
#ns_assign_worker — Concurrent::RubyThreadPoolExecutor
#ns_auto_terminate= — Concurrent::AbstractExecutorService
#ns_auto_terminate? — Concurrent::AbstractExecutorService
#ns_broadcast — Concurrent::Synchronization::AbstractLockableObject
#ns_broadcast — Concurrent::Synchronization::RbxLockableObject
#ns_broadcast — Concurrent::Synchronization::ConditionSignalling
#ns_broadcast — Concurrent::Synchronization::Condition
#ns_check_state? — Concurrent::Concern::Obligation
#ns_complete_without_notification — Concurrent::IVar
#ns_each — Concurrent::Synchronization::AbstractStruct
#ns_each_pair — Concurrent::Synchronization::AbstractStruct
#ns_enqueue — Concurrent::RubyThreadPoolExecutor
#ns_enqueue_job — Concurrent::Agent
#ns_equality — Concurrent::Synchronization::AbstractStruct
#ns_execute — Concurrent::RubyThreadPoolExecutor
#ns_execute — Concurrent::AbstractExecutorService
#ns_find_last_job_for_thread — Concurrent::Agent
#ns_generation_done — Concurrent::CyclicBarrier
#ns_get — Concurrent::Synchronization::AbstractStruct
#ns_initialize — Concurrent::MutexSemaphore
#ns_initialize — Concurrent::IVar
#ns_initialize — Concurrent::Future
#ns_initialize — Concurrent::MutexAtomicBoolean
#ns_initialize — Concurrent::TimerSet
#ns_initialize — Concurrent::Collection::CopyOnWriteObserverSet
#ns_initialize — Concurrent::SimpleExecutorService
#ns_initialize — Concurrent::Collection::CopyOnNotifyObserverSet
#ns_initialize — Concurrent::JavaSingleThreadExecutor
#ns_initialize — Concurrent::Agent
#ns_initialize — Concurrent::Event
#ns_initialize — Concurrent::CyclicBarrier
#ns_initialize — Concurrent::MutexAtomicFixnum
#ns_initialize — Concurrent::MutexCountDownLatch
#ns_initialize — Concurrent::SerializedExecution
#ns_initialize — Concurrent::Promise
#ns_initialize — Concurrent::AtExitImplementation
#ns_initialize — Concurrent::JavaThreadPoolExecutor
#ns_initialize — Concurrent::Synchronization::AbstractStruct
#ns_initialize — Concurrent::RubyThreadPoolExecutor
#ns_initialize — Concurrent::MutexAtomicReference
#ns_initialize — Concurrent::TimerTask
#ns_initialize — Concurrent::Delay
#ns_initialize — Concurrent::CachedThreadPool
#ns_inspect — Concurrent::Synchronization::AbstractStruct
#ns_kill_execution — Concurrent::RubyThreadPoolExecutor
#ns_kill_execution — Concurrent::AbstractExecutorService
#ns_kill_execution — Concurrent::TimerTask
#ns_limited_queue? — Concurrent::RubyThreadPoolExecutor
#ns_make_value — Concurrent::MutexAtomicBoolean
#ns_merge — Concurrent::Synchronization::AbstractStruct
#ns_next_generation — Concurrent::CyclicBarrier
#ns_post_next_job — Concurrent::Agent
#ns_post_task — Concurrent::TimerSet
#ns_prune_pool — Concurrent::RubyThreadPoolExecutor
#ns_ready_worker — Concurrent::RubyThreadPoolExecutor
#ns_remove_busy_worker — Concurrent::RubyThreadPoolExecutor
#ns_reschedule — Concurrent::ScheduledTask
#ns_reset_if_forked — Concurrent::TimerSet
#ns_reset_if_forked — Concurrent::RubyThreadPoolExecutor
#ns_running? — Concurrent::JavaExecutorService
#ns_running? — Concurrent::RubyExecutorService
#ns_schedule — Concurrent::ScheduledTask
#ns_select — Concurrent::Synchronization::AbstractStruct
#ns_set — Concurrent::Event
#ns_set — Concurrent::MutexAtomicFixnum
#ns_set_deref_options — Concurrent::Concern::Dereferenceable
#ns_set_state — Concurrent::Concern::Obligation
#ns_shutdown? — Concurrent::JavaExecutorService
#ns_shutdown? — Concurrent::RubyExecutorService
#ns_shutdown_execution — Concurrent::TimerTask
#ns_shutdown_execution — Concurrent::TimerSet
#ns_shutdown_execution — Concurrent::AbstractExecutorService
#ns_shutdown_execution — Concurrent::RubyThreadPoolExecutor
#ns_shutdown_execution — Concurrent::RubyExecutorService
#ns_shuttingdown? — Concurrent::RubyExecutorService
#ns_shuttingdown? — Concurrent::JavaExecutorService
#ns_signal — Concurrent::Synchronization::AbstractLockableObject
#ns_signal — Concurrent::Synchronization::RbxLockableObject
#ns_signal — Concurrent::Synchronization::Condition
#ns_signal — Concurrent::Synchronization::ConditionSignalling
#ns_to_h — Concurrent::Synchronization::AbstractStruct
#ns_validate — Concurrent::Agent
#ns_values — Concurrent::Synchronization::AbstractStruct
#ns_values_at — Concurrent::Synchronization::AbstractStruct
#ns_wait — Concurrent::Synchronization::AbstractLockableObject
#ns_wait — Concurrent::Synchronization::MonitorLockableObject
#ns_wait — Concurrent::Synchronization::MutexLockableObject
#ns_wait — Concurrent::Synchronization::RbxLockableObject
#ns_wait — Concurrent::Synchronization::Condition
#ns_wait_until — Concurrent::Synchronization::Condition
#ns_wait_until — Concurrent::Synchronization::AbstractLockableObject
#ns_worker_died — Concurrent::RubyThreadPoolExecutor
#ns_worker_not_old_enough — Concurrent::RubyThreadPoolExecutor
#number_waiting — Concurrent::CyclicBarrier
#observers — Concurrent::Collection::CopyOnWriteObserverSet
#observers= — Concurrent::Collection::CopyOnWriteObserverSet
#on_blocker_resolution — Concurrent::Promises::BlockedPromise
#on_cruby? — Concurrent::Utility::EngineDetector
#on_error — Concurrent::Promise
#on_fulfill — Concurrent::Promise
#on_fulfillment — Concurrent::Promises::Future
#on_fulfillment! — Concurrent::Promises::Future
#on_fulfillment_using — Concurrent::Promises::Future
#on_jruby? — Concurrent::Utility::EngineDetector
#on_jruby_9000? — Concurrent::Utility::EngineDetector
#on_linux? — Concurrent::Utility::EngineDetector
#on_osx? — Concurrent::Utility::EngineDetector
#on_rbx? — Concurrent::Utility::EngineDetector
#on_reject — Concurrent::Promise
#on_rejection — Concurrent::Promises::Future
#on_rejection! — Concurrent::Promises::Future
#on_rejection_using — Concurrent::Promises::Future
#on_resolution — Concurrent::Promises::AbstractEventFuture
#on_resolution! — Concurrent::Promises::AbstractEventFuture
#on_resolution_using — Concurrent::Promises::AbstractEventFuture
#on_resolvable — Concurrent::Promises::FutureWrapperPromise
#on_resolvable — Concurrent::Promises::AnyResolvedFuturePromise
#on_resolvable — Concurrent::Promises::ZipEventsPromise
#on_resolvable — Concurrent::Promises::ZipFuturesPromise
#on_resolvable — Concurrent::Promises::ThenPromise
#on_resolvable — Concurrent::Promises::RescuePromise
#on_resolvable — Concurrent::Promises::AbstractFlatPromise
#on_resolvable — Concurrent::Promises::ChainPromise
#on_resolvable — Concurrent::Promises::ZipEventEventPromise
#on_resolvable — Concurrent::Promises::BlockedPromise
#on_resolvable — Concurrent::Promises::AnyResolvedEventPromise
#on_resolvable — Concurrent::Promises::ZipFutureEventPromise
#on_resolvable — Concurrent::Promises::EventWrapperPromise
#on_success — Concurrent::Promise
#on_truffleruby? — Concurrent::Utility::EngineDetector
#on_windows? — Concurrent::Utility::EngineDetector
#or — Concurrent::Maybe
#ordered? — Concurrent::Collection::RubyNonConcurrentPriorityQueue
#pair? — Concurrent::Collection::NonConcurrentMapBackend
#parties — Concurrent::CyclicBarrier
#peek — Concurrent::Collection::RubyNonConcurrentPriorityQueue
#peek — Concurrent::Collection::JavaNonConcurrentPriorityQueue
#peek — Concurrent::LockFreeStack
#pending? — Concurrent::Promises::AbstractEventFuture
#pending? — Concurrent::Concern::Obligation
#perform — Concurrent::Async::AsyncDelegator
#physical_processor_count — Concurrent::Utility::ProcessorCounter
#pop — Concurrent::LockFreeStack
#pop — Concurrent::Collection::RubyNonConcurrentPriorityQueue
#pop — Concurrent::Collection::JavaNonConcurrentPriorityQueue
#populate_from — Concurrent::Map
#post — Concurrent::JavaExecutorService
#post — Concurrent::SimpleExecutorService
#post — Concurrent::RubyExecutorService
#post — Concurrent::TimerSet
#post — Concurrent::SerializedExecutionDelegator
#post — Concurrent::ImmediateExecutor
#post — Concurrent::IndirectImmediateExecutor
#post — Concurrent::ExecutorService
#post — Concurrent::SerializedExecution
#post — Concurrent::Agent
#post_task — Concurrent::TimerSet
#posts — Concurrent::SerializedExecution
#pr_underscore — Concurrent::Synchronization::AbstractStruct
#process_on_blocker_resolution — Concurrent::Promises::ZipFutureEventPromise
#process_on_blocker_resolution — Concurrent::Promises::RunFuturePromise
#process_on_blocker_resolution — Concurrent::Promises::BlockedPromise
#process_on_blocker_resolution — Concurrent::Promises::FlatFuturePromise
#process_on_blocker_resolution — Concurrent::Promises::FlatEventPromise
#process_on_blocker_resolution — Concurrent::Promises::ZipFuturesPromise
#process_task — Concurrent::ScheduledTask
#process_tasks — Concurrent::TimerSet
#processing? — Concurrent::ScheduledTask
#processor_count — Concurrent::Utility::ProcessorCounter
#promise — Concurrent::Promises::AbstractEventFuture
#pure_hash — Concurrent::Collection::AtomicReferenceMapBackend::Node
#push — Concurrent::Collection::JavaNonConcurrentPriorityQueue
#push — Concurrent::Collection::RubyNonConcurrentPriorityQueue
#push — Concurrent::LockFreeStack
#put — Concurrent::MVar
#put_if_absent — Concurrent::Map
#queue_length — Concurrent::RubyThreadPoolExecutor
#queue_length — Concurrent::JavaThreadPoolExecutor
#raise_fetch_no_key — Concurrent::Map
#read — Concurrent::Transaction
#ready_worker — Concurrent::RubyThreadPoolExecutor
#realize — Concurrent::Promise
#realized? — Concurrent::Concern::Obligation
#reason — Concurrent::Promises::Future
#reason — Concurrent::Promises::InternalStates::Rejected
#reason — Concurrent::Promises::InternalStates::Fulfilled
#reason — Concurrent::Promises::InternalStates::PartiallyRejected
#reason — Concurrent::Agent
#reason — Concurrent::Promises::InternalStates::ResolvedWithResult
#reason — Concurrent::Concern::Obligation
#rebuild — Concurrent::Collection
#reconfigure — Concurrent::Delay
#reduce_permits — Concurrent::MutexSemaphore
#reject — Concurrent::Promises::ResolvableFuturePromise
#reject — Concurrent::Promises::ResolvableFuture
#rejected? — Concurrent::Concern::Obligation
#rejected? — Concurrent::Promises::Future
#rejected? — Concurrent::Maybe
#rejected_future — Concurrent::Promises::FactoryMethods
#rejected_resolution — Concurrent::Promises::Event
#rejected_resolution — Concurrent::Promises::Future
#release — Concurrent::MutexSemaphore
#release_read_lock — Concurrent::ReadWriteLock
#release_read_lock — Concurrent::ReentrantReadWriteLock
#release_write_lock — Concurrent::ReadWriteLock
#release_write_lock — Concurrent::ReentrantReadWriteLock
#remaining_capacity — Concurrent::RubyThreadPoolExecutor
#remaining_capacity — Concurrent::JavaThreadPoolExecutor
#remove_busy_worker — Concurrent::RubyThreadPoolExecutor
#remove_task — Concurrent::TimerSet
#replace_if — Concurrent::LockFreeStack
#replace_if_exists — Concurrent::Collection::MriMapBackend
#replace_if_exists — Concurrent::Collection::SynchronizedMapBackend
#replace_if_exists — Concurrent::Collection::AtomicReferenceMapBackend
#replace_if_exists — Concurrent::Collection::NonConcurrentMapBackend
#replace_pair — Concurrent::Collection::MriMapBackend
#replace_pair — Concurrent::Collection::AtomicReferenceMapBackend
#replace_pair — Concurrent::Collection::SynchronizedMapBackend
#replace_pair — Concurrent::Collection::NonConcurrentMapBackend
#reschedule — Concurrent::ScheduledTask
#rescue — Concurrent::Promises::Future
#rescue — Concurrent::Promise
#rescue_on — Concurrent::Promises::Future
#reset — Concurrent::ScheduledTask
#reset — Concurrent::CyclicBarrier
#reset — Concurrent::Atom
#reset — Concurrent::Event
#reset — Concurrent::ThreadSafe::Util::Adder
#resolvable? — Concurrent::Promises::AbstractFlatPromise
#resolvable? — Concurrent::Promises::AnyResolvedEventPromise
#resolvable? — Concurrent::Promises::BlockedPromise
#resolvable? — Concurrent::Promises::AnyFulfilledFuturePromise
#resolvable? — Concurrent::Promises::AnyResolvedFuturePromise
#resolvable_event — Concurrent::Promises::FactoryMethods
#resolvable_event_on — Concurrent::Promises::FactoryMethods
#resolvable_future — Concurrent::Promises::FactoryMethods
#resolvable_future_on — Concurrent::Promises::FactoryMethods
#resolve — Concurrent::Promises::ResolvableEvent
#resolve — Concurrent::Promises::ResolvableFuture
#resolve_with — Concurrent::Promises::AbstractPromise
#resolve_with — Concurrent::Promises::AbstractEventFuture
#resolved? — Concurrent::Promises::InternalStates::ResolvedWithResult
#resolved? — Concurrent::Promises::InternalStates::Pending
#resolved? — Concurrent::Promises::InternalStates::State
#resolved? — Concurrent::Promises::AbstractEventFuture
#resolved_event — Concurrent::Promises::FactoryMethods
#resolved_future — Concurrent::Promises::FactoryMethods
#restart — Concurrent::Agent
#result — Concurrent::Promises::InternalStates::ResolvedWithResult
#result — Concurrent::Promises::Future
#retry_update — Concurrent::ThreadSafe::Util::Striped64
#ruby_engine — Concurrent::Utility::EngineDetector
#ruby_version — Concurrent::Utility::EngineDetector
#run — Concurrent::AtExitImplementation
#run — Concurrent::JavaExecutorService::Job
#run — Concurrent::Promises::Future
#run_task — Concurrent::RubyThreadPoolExecutor::Worker
#runner — Concurrent::AtExitImplementation
#running? — Concurrent::TimerTask
#running? — Concurrent::AbstractExecutorService
#running? — Concurrent::ImmediateExecutor
#running? — Concurrent::JavaThreadPoolExecutor
#running? — Concurrent::SimpleExecutorService
#running_readers — Concurrent::ReadWriteLock
#running_readers — Concurrent::ReentrantReadWriteLock
#running_readers? — Concurrent::ReentrantReadWriteLock
#running_readers? — Concurrent::ReadWriteLock
#running_writer? — Concurrent::ReadWriteLock
#running_writer? — Concurrent::ReentrantReadWriteLock
#safe_execute — Concurrent::IVar
#schedule — Concurrent::Promises::FactoryMethods
#schedule — Concurrent::Promises::Event
#schedule — Concurrent::Promises::Future
#schedule_next_task — Concurrent::TimerTask
#schedule_on — Concurrent::Promises::FactoryMethods
#schedule_time — Concurrent::ScheduledTask
#scheduled_task_count — Concurrent::RubyThreadPoolExecutor
#scheduled_task_count — Concurrent::JavaThreadPoolExecutor
#select — Concurrent::MutableStruct
#select — Concurrent::ImmutableStruct
#select — Concurrent::SettableStruct
#send — Concurrent::Agent
#send! — Concurrent::Agent
#send_off — Concurrent::Agent
#send_off! — Concurrent::Agent
#send_via — Concurrent::Agent
#send_via! — Concurrent::Agent
#serialized? — Concurrent::SerialExecutorService
#serialized? — Concurrent::ExecutorService
#set — Concurrent::Future
#set — Concurrent::MutexAtomicReference
#set — Concurrent::Event
#set — Concurrent::Promise
#set — Concurrent::IVar
#set — Concurrent::Tuple
#set — Concurrent::AtomicMarkableReference
#set! — Concurrent::MVar
#set? — Concurrent::Event
#set_c_extensions_loaded — Concurrent::Utility::NativeExtensionLoader
#set_deref_options — Concurrent::Concern::Dereferenceable
#set_java_extensions_loaded — Concurrent::Utility::NativeExtensionLoader
#set_pending — Concurrent::Promise
#set_state — Concurrent::Concern::Obligation
#set_state! — Concurrent::Promise
#set_threadlocal_array — Concurrent::RubyThreadLocalVar
#setup — Concurrent::SynchronizedDelegator
#shift — Concurrent::Collection::RubyNonConcurrentPriorityQueue
#shift — Concurrent::Collection::JavaNonConcurrentPriorityQueue
#shutdown — Concurrent::SimpleExecutorService
#shutdown — Concurrent::JavaExecutorService
#shutdown — Concurrent::RubyExecutorService
#shutdown — Concurrent::ImmediateExecutor
#shutdown — Concurrent::AbstractExecutorService
#shutdown? — Concurrent::AbstractExecutorService
#shutdown? — Concurrent::ImmediateExecutor
#shutdown? — Concurrent::SimpleExecutorService
#shuttingdown? — Concurrent::AbstractExecutorService
#shuttingdown? — Concurrent::ImmediateExecutor
#shuttingdown? — Concurrent::SimpleExecutorService
#signal — Concurrent::Synchronization::Condition
#signal — Concurrent::Synchronization::Lock
#sink — Concurrent::Collection::RubyNonConcurrentPriorityQueue
#size — Concurrent::Map
#size — Concurrent::Collection::NonConcurrentMapBackend
#size — Concurrent::Collection::AtomicReferenceMapBackend
#size — Concurrent::Collection::RubyNonConcurrentPriorityQueue
#size — Concurrent::Synchronization::AbstractStruct
#size — Concurrent::Collection::JavaNonConcurrentPriorityQueue
#size — Concurrent::Collection::SynchronizedMapBackend
#split_bin — Concurrent::Collection
#split_old_bin — Concurrent::Collection
#state — Concurrent::Promises::AbstractEventFuture
#state — Concurrent::Promises::AbstractPromise
#state — Concurrent::Concern::Obligation
#state= — Concurrent::Concern::Obligation
#stop — Concurrent::RubyThreadPoolExecutor::Worker
#stop_event — Concurrent::RubyExecutorService
#stopped? — Concurrent::Agent
#stopped_event — Concurrent::RubyExecutorService
#store_computed_value — Concurrent::Collection::NonConcurrentMapBackend
#sum — Concurrent::ThreadSafe::Util::Adder
#swap — Concurrent::Atom
#swap — Concurrent::Collection::RubyNonConcurrentPriorityQueue
#swap — Concurrent::MutexAtomicReference
#swim — Concurrent::Collection::RubyNonConcurrentPriorityQueue
#synchronize — Concurrent::Synchronization::MutexLockableObject
#synchronize — Concurrent::Synchronization::AbstractLockableObject
#synchronize — Concurrent::MVar
#synchronize — Concurrent::Synchronization::MonitorLockableObject
#synchronize — Concurrent::Synchronization::RbxLockableObject
#synchronized_set_state! — Concurrent::Promise
#table_size_for — Concurrent::Collection::AtomicReferenceMapBackend
#take — Concurrent::MVar
#tangle — Concurrent::Promises::AbstractEventFuture
#teardown — Concurrent::SynchronizedDelegator
#terminate_at_exit — Concurrent::AbstractExecutorService
#then — Concurrent::Promise
#then — Concurrent::Promises::Future
#then_on — Concurrent::Promises::Future
#timeout_interval — Concurrent::TimerTask
#timeout_interval= — Concurrent::TimerTask
#timeout_task — Concurrent::TimerTask
#to_a — Concurrent::SettableStruct
#to_a — Concurrent::ImmutableStruct
#to_a — Concurrent::MutableStruct
#to_event — Concurrent::Promises::Event
#to_event — Concurrent::Promises::Future
#to_future — Concurrent::Promises::Event
#to_future — Concurrent::Promises::Future
#to_h — Concurrent::SettableStruct
#to_h — Concurrent::ImmutableStruct
#to_h — Concurrent::MutableStruct
#to_s — Concurrent::AtomicBoolean
#to_s — Concurrent::MutableStruct
#to_s — Concurrent::Promises::AbstractPromise
#to_s — Concurrent::ImmutableStruct
#to_s — Concurrent::AtomicFixnum
#to_s — Concurrent::LockFreeStack
#to_s — Concurrent::SettableStruct
#to_s — AtomicReference
#to_s — Concurrent::Promises::AbstractEventFuture
#to_sym — Concurrent::Promises::InternalStates::Pending
#to_sym — Concurrent::Promises::InternalStates::PartiallyRejected
#to_sym — Concurrent::Promises::InternalStates::State
#to_sym — Concurrent::Promises::InternalStates::Rejected
#to_sym — Concurrent::Promises::InternalStates::ResolvedWithResult
#to_sym — Concurrent::Promises::InternalStates::Fulfilled
#touch — Concurrent::Promises::DelayPromise
#touch — Concurrent::Promises::AbstractEventFuture
#touch — Concurrent::Promises::AbstractFlatPromise
#touch — Concurrent::Promises::BlockedPromise
#touch — Concurrent::Promises::AbstractPromise
#touched? — Concurrent::Promises::AbstractFlatPromise
#touched? — Concurrent::Promises::AbstractEventFuture
#true? — Concurrent::MutexAtomicBoolean
#try? — Concurrent::Event
#try_acquire — Concurrent::MutexSemaphore
#try_acquire_now — Concurrent::MutexSemaphore
#try_acquire_timed — Concurrent::MutexSemaphore
#try_await_lock — Concurrent::Collection::AtomicReferenceMapBackend
#try_await_lock — Concurrent::Collection::AtomicReferenceMapBackend::Node
#try_exchange — Concurrent::AbstractExchanger
#try_in_busy — Concurrent::ThreadSafe::Util::Striped64
#try_in_resize_lock — Concurrent::Collection
#try_initialize_cells — Concurrent::ThreadSafe::Util::Striped64
#try_load_c_extension — Concurrent::Utility::NativeExtensionLoader
#try_lock_via_hash — Concurrent::Collection::AtomicReferenceMapBackend::Node
#try_lock_via_hash — Concurrent::Collection::AtomicReferenceMapBackend::Table
#try_put! — Concurrent::MVar
#try_read_lock — Concurrent::ReentrantReadWriteLock
#try_set — Concurrent::IVar
#try_take! — Concurrent::MVar
#try_to_cas_in_computed — Concurrent::Collection::AtomicReferenceMapBackend::Table
#try_to_install_new_cell — Concurrent::ThreadSafe::Util::Striped64
#try_update — Concurrent::AtomicMarkableReference
#try_update — Concurrent::AtomicDirectUpdate
#try_update! — Concurrent::AtomicDirectUpdate
#try_update! — Concurrent::AtomicMarkableReference
#try_write_lock — Concurrent::ReentrantReadWriteLock
#unlock — Concurrent::Transaction
#unlock_via_hash — Concurrent::Collection::AtomicReferenceMapBackend::Node
#unlocked_empty? — Concurrent::MVar
#unlocked_full? — Concurrent::MVar
#unscheduled? — Concurrent::Concern::Obligation
#up — Concurrent::MutexAtomicFixnum
#update — Concurrent::AtomicDirectUpdate
#update — Concurrent::AtomicMarkableReference
#update — Concurrent::MutexAtomicFixnum
#valid? — Concurrent::Transaction
#valid? — Concurrent::Atom
#validate_options_hash! — Concurrent::Map
#value — Concurrent::RubyThreadLocalVar
#value — Concurrent::Promises::InternalStates::Fulfilled
#value — Concurrent::TVar
#value — Concurrent::Promises::InternalStates::ResolvedWithResult
#value — Concurrent::AbstractThreadLocalVar
#value — Concurrent::Promises::InternalStates::Rejected
#value — Concurrent::MutexAtomicBoolean
#value — Concurrent::MutexAtomicFixnum
#value — Concurrent::Concern::Obligation
#value — Concurrent::Agent
#value — Concurrent::Concern::Dereferenceable
#value — Concurrent::JavaThreadLocalVar
#value — Concurrent::Promises::InternalStates::PartiallyRejected
#value — Concurrent::AtomicMarkableReference
#value — Concurrent::Promises::Future
#value — Concurrent::Delay
#value — Concurrent::MutexAtomicReference
#value! — Concurrent::Promises::Future
#value! — Concurrent::Concern::Obligation
#value! — Concurrent::Delay
#value= — Concurrent::AbstractThreadLocalVar
#value= — Concurrent::JavaThreadLocalVar
#value= — Concurrent::RubyThreadLocalVar
#value= — Concurrent::Concern::Dereferenceable
#value= — Concurrent::MutexAtomicReference
#value= — Concurrent::MutexAtomicFixnum
#value= — Concurrent::TVar
#value= — Concurrent::MutexAtomicBoolean
#value? — Concurrent::Map
#value_for — Concurrent::RubyThreadLocalVar
#values — Concurrent::MutableStruct
#values — Concurrent::Map
#values — Concurrent::ImmutableStruct
#values — Concurrent::SettableStruct
#values_at — Concurrent::ImmutableStruct
#values_at — Concurrent::SettableStruct
#values_at — Concurrent::MutableStruct
#volatile_get — Concurrent::Tuple
#volatile_get_by_hash — Concurrent::ThreadSafe::Util::PowerOfTwoTuple
#volatile_set — Concurrent::Tuple
#volatile_set_by_hash — Concurrent::ThreadSafe::Util::PowerOfTwoTuple
#wait — Concurrent::Event
#wait — Concurrent::Agent
#wait — Concurrent::Synchronization::Condition
#wait — Concurrent::JavaCountDownLatch
#wait — Concurrent::Delay
#wait — Concurrent::Promises::AbstractEventFuture
#wait — Concurrent::MutexCountDownLatch
#wait — Concurrent::Synchronization::Lock
#wait — Concurrent::Concern::Obligation
#wait — Concurrent::CyclicBarrier
#wait! — Concurrent::Concern::Obligation
#wait! — Concurrent::Promises::Future
#wait_for_empty — Concurrent::MVar
#wait_for_full — Concurrent::MVar
#wait_for_termination — Concurrent::AbstractExecutorService
#wait_for_termination — Concurrent::SimpleExecutorService
#wait_for_termination — Concurrent::JavaExecutorService
#wait_for_termination — Concurrent::ImmediateExecutor
#wait_for_termination — Concurrent::RubyExecutorService
#wait_or_cancel — Concurrent::Future
#wait_until — Concurrent::Synchronization::Lock
#wait_until — Concurrent::Synchronization::Condition
#wait_until_resolved — Concurrent::Promises::AbstractEventFuture
#wait_until_resolved! — Concurrent::Promises::Future
#wait_while — Concurrent::MVar
#waiting_or_running_writer? — Concurrent::ReentrantReadWriteLock
#waiting_threads — Concurrent::Promises::AbstractEventFuture
#waiting_writer? — Concurrent::ReadWriteLock
#waiting_writers — Concurrent::ReadWriteLock
#waiting_writers — Concurrent::ReentrantReadWriteLock
#with_async — Concurrent::Promises::AbstractEventFuture
#with_default_executor — Concurrent::Promises::Future
#with_default_executor — Concurrent::Promises::AbstractEventFuture
#with_default_executor — Concurrent::Promises::Event
#with_hidden_resolvable — Concurrent::Promises::ResolvableFuture
#with_hidden_resolvable — Concurrent::Promises::ResolvableEvent
#with_observer — Concurrent::Concern::Observable
#with_read_lock — Concurrent::ReentrantReadWriteLock
#with_read_lock — Concurrent::ReadWriteLock
#with_write_lock — Concurrent::ReadWriteLock
#with_write_lock — Concurrent::ReentrantReadWriteLock
#work — Concurrent::SerializedExecution
#worker_died — Concurrent::RubyThreadPoolExecutor
#worker_not_old_enough — Concurrent::RubyThreadPoolExecutor
#worker_task_completed — Concurrent::RubyThreadPoolExecutor
#write — Concurrent::Transaction
#write_locked? — Concurrent::ReadWriteLock
#zip — Concurrent::Promise
#zip — Concurrent::Promises::Event
#zip — Concurrent::Promises::Future
#zip — Concurrent::Promises::FactoryMethods
#zip_events — Concurrent::Promises::FactoryMethods
#zip_events_on — Concurrent::Promises::FactoryMethods
#zip_futures — Concurrent::Promises::FactoryMethods
#zip_futures_on — Concurrent::Promises::FactoryMethods
#| — Concurrent::Promises::Future
#| — Concurrent::Promises::Event