Table of Contents - concurrent-ruby-1.1.9 Documentation
Pages
-
CHANGELOG
- Current
- Release v1.1.9 (5 Jun 2021)
- Release v1.1.8 (20 January 2021)
- Release v1.1.7 (6 August 2020)
- Release v1.1.6, edge v0.6.0 (10 Feb 2020)
- Release v1.1.6.pre1, edge v0.6.0.pre1 (26 Jan 2020)
- Release v1.1.5, edge v0.5.0 (10 Mar 2019)
- 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
- Building the gem
- Requirements
- Publishing the Gem
- Maintainers
- Special Thanks to
- License and Copyright
Classes and 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::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::Collection::TruffleRubyMapBackend
- Concurrent::Concern
- Concurrent::Concern::Deprecation
- Concurrent::Concern::Dereferenceable
- Concurrent::Concern::Logging
- Concurrent::Concern::Obligation
- Concurrent::Concern::Observable
- Concurrent::ConcurrentUpdateError
- Concurrent::CountDownLatch
- Concurrent::CyclicBarrier
- Concurrent::DaemonThreadFactory
- Concurrent::Delay
- Concurrent::DependencyCounter
- Concurrent::Event
- Concurrent::Exchanger
- Concurrent::ExecutorService
- Concurrent::FixedThreadPool
- Concurrent::Future
- Concurrent::IVar
- Concurrent::ImmediateExecutor
- Concurrent::ImmutableStruct
- Concurrent::IndirectImmediateExecutor
- Concurrent::JRubySet
- 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::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::Reserved
- 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::ThreadSafe::Util::XorShiftRandom
- 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
- ::atomic_attribute? — Concurrent::Synchronization::Object
- ::atomic_attributes — Concurrent::Synchronization::Object
- ::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_atomic_fields — 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::Future
- ::execute — Concurrent::Promise
- ::execute — Concurrent::ScheduledTask
- ::execute — Concurrent::TimerTask
- ::executor — Concurrent
- ::executor — Concurrent::Options
- ::from — Concurrent::Maybe
- ::from_list — Concurrent::Collection::JavaNonConcurrentPriorityQueue
- ::from_list — Concurrent::Collection::RubyNonConcurrentPriorityQueue
- ::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::ImmutableStruct
- ::included — Concurrent::Synchronization::JRubyAttrVolatile
- ::included — Concurrent::Synchronization::MriAttrVolatile
- ::included — Concurrent::Synchronization::RbxAttrVolatile
- ::included — Concurrent::Synchronization::TruffleRubyAttrVolatile
- ::just — Concurrent::Maybe
- ::leave_transaction — Concurrent
- ::locked_hash? — Concurrent::Collection::AtomicReferenceMapBackend::Node
- ::make_synchronized_on_cruby — Concurrent::ThreadSafe::Util
- ::make_synchronized_on_rbx — Concurrent::ThreadSafe::Util
- ::make_synchronized_on_truffleruby — Concurrent::ThreadSafe::Util
- ::monotonic_time — Concurrent
- ::new — Concurrent::Agent
- ::new — Concurrent::Agent::Error
- ::new — Concurrent::Agent::ValidationError
- ::new — Concurrent::Async::AsyncDelegator
- ::new — Concurrent::Async::AwaitDelegator
- ::new — Concurrent::Atom
- ::new — Concurrent::AbstractThreadLocalVar
- ::new — Concurrent::AtomicMarkableReference
- ::new — Concurrent::CyclicBarrier
- ::new — Concurrent::Event
- ::new — Concurrent::JavaCountDownLatch
- ::new — Concurrent::MutexAtomicBoolean
- ::new — Concurrent::MutexAtomicFixnum
- ::new — Concurrent::MutexCountDownLatch
- ::new — Concurrent::MutexSemaphore
- ::new — Concurrent::ReadWriteLock
- ::new — Concurrent::ReentrantReadWriteLock
- ::new — Concurrent::MutexAtomicReference
- ::new — Concurrent::Collection::CopyOnNotifyObserverSet
- ::new — Concurrent::Collection::CopyOnWriteObserverSet
- ::new — Concurrent::Collection::JavaNonConcurrentPriorityQueue
- ::new — Concurrent::LockFreeStack
- ::new — Concurrent::LockFreeStack::Node
- ::new — Concurrent::Collection::AtomicReferenceMapBackend
- ::new — Concurrent::Collection::AtomicReferenceMapBackend::Node
- ::new — Concurrent::Collection::MriMapBackend
- ::new — Concurrent::Collection::NonConcurrentMapBackend
- ::new — Concurrent::Collection::TruffleRubyMapBackend
- ::new — Concurrent::Collection::RubyNonConcurrentPriorityQueue
- ::new — Concurrent::Delay
- ::new — Concurrent::MultipleAssignmentError
- ::new — Concurrent::MultipleErrors
- ::new — Concurrent::AbstractExchanger
- ::new — Concurrent::RubyExchanger
- ::new — Concurrent::RubyExchanger::Node
- ::new — Concurrent::JavaExchanger
- ::new — Concurrent::AbstractExecutorService
- ::new — Concurrent::CachedThreadPool
- ::new — Concurrent::FixedThreadPool
- ::new — Concurrent::ImmediateExecutor
- ::new — Concurrent::IndirectImmediateExecutor
- ::new — Concurrent::JavaExecutorService::Job
- ::new — Concurrent::DaemonThreadFactory
- ::new — Concurrent::JavaSingleThreadExecutor
- ::new — Concurrent::JavaThreadPoolExecutor
- ::new — Concurrent::RubyExecutorService
- ::new — Concurrent::RubySingleThreadExecutor
- ::new — Concurrent::RubyThreadPoolExecutor
- ::new — Concurrent::RubyThreadPoolExecutor::Worker
- ::new — Concurrent::SafeTaskExecutor
- ::new — Concurrent::SerializedExecution
- ::new — Concurrent::SerializedExecutionDelegator
- ::new — Concurrent::TimerSet
- ::new — Concurrent::Future
- ::new — Concurrent::IVar
- ::new — Concurrent::Map
- ::new — Concurrent::Maybe
- ::new — Concurrent::MVar
- ::new — Concurrent::Promise
- ::new — Concurrent::Promises::InternalStates::Fulfilled
- ::new — Concurrent::Promises::InternalStates::Rejected
- ::new — Concurrent::Promises::InternalStates::PartiallyRejected
- ::new — Concurrent::Promises::AbstractEventFuture
- ::new — Concurrent::Promises::AbstractPromise
- ::new — Concurrent::Promises::ResolvableEventPromise
- ::new — Concurrent::Promises::ResolvableFuturePromise
- ::new — Concurrent::Promises::BlockedPromise
- ::new — Concurrent::Promises::BlockedPromise
- ::new — Concurrent::Promises::BlockedTaskPromise
- ::new — Concurrent::Promises::ThenPromise
- ::new — Concurrent::Promises::RescuePromise
- ::new — Concurrent::Promises::ImmediateEventPromise
- ::new — Concurrent::Promises::ImmediateFuturePromise
- ::new — Concurrent::Promises::AbstractFlatPromise
- ::new — Concurrent::Promises::FlatEventPromise
- ::new — Concurrent::Promises::FlatFuturePromise
- ::new — Concurrent::Promises::RunFuturePromise
- ::new — Concurrent::Promises::ZipEventEventPromise
- ::new — Concurrent::Promises::ZipFutureEventPromise
- ::new — Concurrent::Promises::EventWrapperPromise
- ::new — Concurrent::Promises::FutureWrapperPromise
- ::new — Concurrent::Promises::ZipFuturesPromise
- ::new — Concurrent::Promises::ZipEventsPromise
- ::new — Concurrent::Promises::AnyResolvedEventPromise
- ::new — Concurrent::Promises::AnyResolvedFuturePromise
- ::new — Concurrent::Promises::DelayPromise
- ::new — Concurrent::Promises::ScheduledPromise
- ::new — Concurrent::ScheduledTask
- ::new — Concurrent::Synchronization::AbstractObject
- ::new — Concurrent::Synchronization::Condition
- ::new — Concurrent::Synchronization::JRubyObject
- ::new — Concurrent::Synchronization::MriObject
- ::new — Concurrent::Synchronization::MutexLockableObject
- ::new — Concurrent::Synchronization::MonitorLockableObject
- ::new — Concurrent::Synchronization::Object
- ::new — Concurrent::Synchronization::Object
- ::new — Concurrent::Synchronization::RbxLockableObject
- ::new — Concurrent::Synchronization::RbxObject
- ::new — Concurrent::Synchronization::TruffleRubyObject
- ::new — Concurrent::SynchronizedDelegator
- ::new — Concurrent::ThreadSafe::Util::PowerOfTwoTuple
- ::new — Concurrent::ThreadSafe::Util::Striped64
- ::new — Concurrent::TimerTask
- ::new — Concurrent::Tuple
- ::new — Concurrent::TVar
- ::new — Concurrent::Transaction
- ::new — Concurrent::Utility::ProcessorCounter
- ::new — Concurrent
- ::new — Concurrent::ImmutableStruct
- ::new — Concurrent::MutableStruct
- ::new — Concurrent::SettableStruct
- ::new — Concurrent::Synchronization::AbstractStruct
- ::new — Concurrent::ThreadSafe::Util
- ::new — Concurrent::ThreadSafe::Util
- ::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
- ::semi_sync — Concurrent::RubyThreadLocalVar
- ::synchronized — TruffleRuby
- ::thread_finalizer — Concurrent::RubyThreadLocalVar
- ::thread_local_finalizer — Concurrent::RubyThreadLocalVar
- ::use_simple_logger — Concurrent
- ::use_stdlib_logger — Concurrent
- ::validate_argc — Concurrent::Async
- ::zip — Concurrent::Promise
- #& — Concurrent::Promises::Event
- #& — Concurrent::Promises::Future
- #<< — Concurrent::Agent
- #<< — Concurrent::Collection::JavaNonConcurrentPriorityQueue
- #<< — Concurrent::Collection::RubyNonConcurrentPriorityQueue
- #<< — Concurrent::ImmediateExecutor
- #<< — Concurrent::RubyThreadPoolExecutor::Worker
- #<< — Concurrent::SimpleExecutorService
- #<< — Concurrent::ExecutorService
- #<=> — Concurrent::Maybe
- #<=> — Concurrent::ScheduledTask
- #== — Concurrent::ImmutableStruct
- #== — Concurrent::MutableStruct
- #== — Concurrent::SettableStruct
- #[] — Concurrent::Collection::AtomicReferenceMapBackend
- #[] — Concurrent::Collection::NonConcurrentMapBackend
- #[] — Concurrent::Collection::SynchronizedMapBackend
- #[] — Concurrent::Map
- #[] — Concurrent::ImmutableStruct
- #[] — Concurrent::MutableStruct
- #[] — Concurrent::SettableStruct
- #[]= — Concurrent::Collection::AtomicReferenceMapBackend
- #[]= — Concurrent::Collection::MriMapBackend
- #[]= — Concurrent::Collection::NonConcurrentMapBackend
- #[]= — Concurrent::Collection::SynchronizedMapBackend
- #[]= — Concurrent::Map
- #[]= — Concurrent::MutableStruct
- #[]= — Concurrent::SettableStruct
- #__initialize_atomic_fields__ — Concurrent::Synchronization::Object
- #_compare_and_set — Concurrent::MutexAtomicReference
- #_get — Concurrent::Collection::NonConcurrentMapBackend
- #_mon_initialize — Concurrent::ThreadSafe::Util
- #_set — Concurrent::Collection::NonConcurrentMapBackend
- #| — Concurrent::Promises::Event
- #| — Concurrent::Promises::Future
- #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::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::Collection::CopyOnNotifyObserverSet
- #add_observer — Concurrent::Collection::CopyOnWriteObserverSet
- #add_observer — Concurrent::IVar
- #add_observer — Concurrent::Concern::Observable
- #allocate_storage — Concurrent::AbstractThreadLocalVar
- #allocate_storage — Concurrent::JavaThreadLocalVar
- #allocate_storage — Concurrent::RubyThreadLocalVar
- #allow_c_extensions? — Concurrent::Utility::NativeExtensionLoader
- #any — Concurrent::Promises::Event
- #any — Concurrent::Promises::Future
- #any — Concurrent::Promises::FactoryMethods
- #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::ResolvedWithResult
- #apply — Concurrent::Promises::InternalStates::Fulfilled
- #apply — Concurrent::Promises::InternalStates::FulfilledArray
- #apply — Concurrent::Promises::InternalStates::Rejected
- #apply — Concurrent::Promises::InternalStates::PartiallyRejected
- #apply — Concurrent::Promises::Future
- #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::Synchronization::JRubyAttrVolatile::ClassMethods
- #attr_volatile — Concurrent::Synchronization::MriAttrVolatile::ClassMethods
- #attr_volatile — Concurrent::Synchronization::RbxAttrVolatile::ClassMethods
- #attr_volatile — Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods
- #attr_volatile — Concurrent::ThreadSafe::Util::Volatile
- #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::Event
- #callback_on_resolution — Concurrent::Promises::Future
- #callbacks — Concurrent::Promises::AbstractEventFuture
- #can_overflow? — Concurrent::JavaThreadPoolExecutor
- #can_overflow? — Concurrent::RubyThreadPoolExecutor
- #can_overflow? — Concurrent::ExecutorService
- #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::JavaNonConcurrentPriorityQueue
- #clear — Concurrent::LockFreeStack
- #clear — Concurrent::Collection::AtomicReferenceMapBackend
- #clear — Concurrent::Collection::MriMapBackend
- #clear — Concurrent::Collection::NonConcurrentMapBackend
- #clear — Concurrent::Collection::SynchronizedMapBackend
- #clear — Concurrent::Collection::RubyNonConcurrentPriorityQueue
- #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::Atom
- #compare_and_set — Concurrent::AtomicMarkableReference
- #compare_and_set — Concurrent::MutexAtomicFixnum
- #compare_and_set — Concurrent::Tuple
- #compare_and_set — Concurrent::AtomicNumericCompareAndSetWrapper
- #compare_and_set_state — Concurrent::Concern::Obligation
- #compare_and_swap — Concurrent::AtomicMarkableReference
- #complete — Concurrent::IVar
- #complete — Concurrent::Promise
- #complete? — Concurrent::Concern::Obligation
- #complete_without_notification — Concurrent::IVar
- #completed_task_count — Concurrent::JavaThreadPoolExecutor
- #completed_task_count — Concurrent::RubyThreadPoolExecutor
- #compute — Concurrent::Collection::AtomicReferenceMapBackend
- #compute — Concurrent::Collection::MriMapBackend
- #compute — Concurrent::Collection::NonConcurrentMapBackend
- #compute — Concurrent::Collection::SynchronizedMapBackend
- #compute_if_absent — Concurrent::Collection::AtomicReferenceMapBackend
- #compute_if_absent — Concurrent::Collection::MriMapBackend
- #compute_if_absent — Concurrent::Collection::NonConcurrentMapBackend
- #compute_if_absent — Concurrent::Collection::SynchronizedMapBackend
- #compute_if_present — Concurrent::Collection::AtomicReferenceMapBackend
- #compute_if_present — Concurrent::Collection::MriMapBackend
- #compute_if_present — Concurrent::Collection::NonConcurrentMapBackend
- #compute_if_present — Concurrent::Collection::SynchronizedMapBackend
- #compute_physical_processor_count — Concurrent::Utility::ProcessorCounter
- #compute_processor_count — Concurrent::Utility::ProcessorCounter
- #count — Concurrent::JavaCountDownLatch
- #count — Concurrent::MutexCountDownLatch
- #count_down — Concurrent::JavaCountDownLatch
- #count_down — Concurrent::MutexCountDownLatch
- #count_observers — Concurrent::Collection::CopyOnNotifyObserverSet
- #count_observers — Concurrent::Collection::CopyOnWriteObserverSet
- #count_observers — Concurrent::Concern::Observable
- #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::AtomicReferenceMapBackend
- #default — Concurrent::AbstractThreadLocalVar
- #default_executor — Concurrent::Promises::AbstractEventFuture
- #default_executor — Concurrent::Promises::AbstractPromise
- #default_executor — Concurrent::Promises::FactoryMethods::Configuration
- #delay — Concurrent::Promises::Event
- #delay — Concurrent::Promises::Future
- #delay — Concurrent::Promises::FactoryMethods
- #delay_on — Concurrent::Promises::FactoryMethods
- #delayed_because — Concurrent::Promises::AbstractPromise
- #delayed_because — Concurrent::Promises::BlockedPromise
- #delayed_because — Concurrent::Promises::DelayPromise
- #delete — Concurrent::Collection::JavaNonConcurrentPriorityQueue
- #delete — Concurrent::Collection::AtomicReferenceMapBackend
- #delete — Concurrent::Collection::MriMapBackend
- #delete — Concurrent::Collection::NonConcurrentMapBackend
- #delete — Concurrent::Collection::SynchronizedMapBackend
- #delete — Concurrent::Collection::RubyNonConcurrentPriorityQueue
- #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::MriMapBackend
- #delete_pair — Concurrent::Collection::NonConcurrentMapBackend
- #delete_pair — Concurrent::Collection::SynchronizedMapBackend
- #deprecated — Concurrent::Concern::Deprecation
- #deprecated_method — Concurrent::Concern::Deprecation
- #deq — Concurrent::Collection::JavaNonConcurrentPriorityQueue
- #deq — Concurrent::Collection::RubyNonConcurrentPriorityQueue
- #deref — Concurrent::Agent
- #deref — Concurrent::Concern::Dereferenceable
- #do_exchange — Concurrent::AbstractExchanger
- #do_exchange — Concurrent::RubyExchanger
- #do_exchange — Concurrent::JavaExchanger
- #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::LockFreeStack
- #each — Concurrent::Map
- #each — Concurrent::Tuple
- #each — Concurrent::ImmutableStruct
- #each — Concurrent::MutableStruct
- #each — Concurrent::SettableStruct
- #each_key — Concurrent::Map
- #each_pair — Concurrent::Collection::AtomicReferenceMapBackend
- #each_pair — Concurrent::Collection::NonConcurrentMapBackend
- #each_pair — Concurrent::Map
- #each_pair — Concurrent::ImmutableStruct
- #each_pair — Concurrent::MutableStruct
- #each_pair — Concurrent::SettableStruct
- #each_value — Concurrent::Map
- #empty? — Concurrent::Collection::JavaNonConcurrentPriorityQueue
- #empty? — Concurrent::LockFreeStack
- #empty? — Concurrent::Collection::AtomicReferenceMapBackend
- #empty? — Concurrent::Collection::RubyNonConcurrentPriorityQueue
- #empty? — Concurrent::Map
- #empty? — Concurrent::MVar
- #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::ResolvableFuture
- #evaluate_to — Concurrent::Promises::AbstractPromise
- #evaluate_to! — Concurrent::Promises::ResolvableFuture
- #event — Concurrent::Promises::AbstractPromise
- #event — Concurrent::Concern::Obligation
- #exception — Concurrent::Promises::Future
- #exception — Concurrent::Concern::Obligation
- #exchange — Concurrent::AbstractExchanger
- #exchange! — Concurrent::AbstractExchanger
- #execute — Concurrent::SafeTaskExecutor
- #execute — Concurrent::Future
- #execute — Concurrent::Promise
- #execute — Concurrent::ScheduledTask
- #execute — Concurrent::TimerTask
- #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::ResolvableFuture
- #fulfilled? — Concurrent::Maybe
- #fulfilled? — Concurrent::Promises::InternalStates::ResolvedWithResult
- #fulfilled? — Concurrent::Promises::InternalStates::Fulfilled
- #fulfilled? — Concurrent::Promises::InternalStates::Rejected
- #fulfilled? — Concurrent::Promises::InternalStates::PartiallyRejected
- #fulfilled? — Concurrent::Promises::Future
- #fulfilled? — Concurrent::Concern::Obligation
- #fulfilled_future — Concurrent::Promises::FactoryMethods
- #full? — Concurrent::MVar
- #full_memory_barrier — Concurrent::Synchronization::AbstractObject
- #full_memory_barrier — Concurrent::Synchronization::MriAttrVolatile
- #full_memory_barrier — Concurrent::Synchronization::RbxAttrVolatile
- #full_memory_barrier — Concurrent::Synchronization::TruffleRubyAttrVolatile
- #future — Concurrent::Promises::AbstractPromise
- #future — Concurrent::Promises::FactoryMethods
- #future_on — Concurrent::Promises::FactoryMethods
- #get — Concurrent::AtomicMarkableReference
- #get — Concurrent::MutexAtomicReference
- #get — Concurrent::Map
- #get — Concurrent::Tuple
- #get — Concurrent::ThreadSafe::Util::XorShiftRandom
- #get_and_set — Concurrent::MutexAtomicReference
- #get_and_set — Concurrent::Collection::AtomicReferenceMapBackend
- #get_and_set — Concurrent::Collection::MriMapBackend
- #get_and_set — Concurrent::Collection::NonConcurrentMapBackend
- #get_and_set — Concurrent::Collection::SynchronizedMapBackend
- #get_arguments_from — Concurrent::Concern::Obligation
- #get_default — Concurrent::RubyThreadLocalVar
- #get_or_default — Concurrent::Collection::AtomicReferenceMapBackend
- #get_or_default — Concurrent::Collection::NonConcurrentMapBackend
- #get_or_default — Concurrent::Collection::SynchronizedMapBackend
- #get_threadlocal_array — Concurrent::RubyThreadLocalVar
- #get_time — Concurrent
- #handle_error — Concurrent::Agent
- #handle_fallback — Concurrent::AbstractExecutorService
- #has_priority? — Concurrent::Collection::JavaNonConcurrentPriorityQueue
- #has_priority? — Concurrent::Collection::RubyNonConcurrentPriorityQueue
- #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::AtomicReferenceMapBackend
- #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_copy — Concurrent::Synchronization::MutexLockableObject
- #initialize_copy — Concurrent::Synchronization::MonitorLockableObject
- #initialize_copy — Concurrent::Synchronization::RbxLockableObject
- #initialize_copy — Concurrent::ImmutableStruct
- #initialize_copy — Concurrent::MutableStruct
- #initialize_copy — Concurrent::SettableStruct
- #initialize_copy — Concurrent::ThreadSafe::Util
- #initialize_table — Concurrent::Collection::AtomicReferenceMapBackend
- #inspect — Concurrent::AtomicBoolean
- #inspect — Concurrent::AtomicFixnum
- #inspect — AtomicReference
- #inspect — Concurrent::LockFreeStack
- #inspect — Concurrent::MultipleAssignmentError
- #inspect — Concurrent::Map
- #inspect — Concurrent::Promises::AbstractEventFuture
- #inspect — Concurrent::Promises::Future
- #inspect — Concurrent::Promises::AbstractPromise
- #inspect — Concurrent::Promises::ScheduledPromise
- #inspect — Concurrent::ImmutableStruct
- #inspect — Concurrent::MutableStruct
- #inspect — Concurrent::SettableStruct
- #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::AtomicReferenceMapBackend
- #key? — Concurrent::Collection::AtomicReferenceMapBackend::Node
- #key? — Concurrent::Collection::NonConcurrentMapBackend
- #key? — Concurrent::Collection::SynchronizedMapBackend
- #key_hash — Concurrent::Collection::AtomicReferenceMapBackend
- #keys — Concurrent::Map
- #kill — Concurrent::AbstractExecutorService
- #kill — Concurrent::ImmediateExecutor
- #kill — Concurrent::JavaExecutorService
- #kill — Concurrent::RubyExecutorService
- #kill — Concurrent::RubyThreadPoolExecutor::Worker
- #kill — Concurrent::SimpleExecutorService
- #kill — Concurrent::TimerSet
- #largest_length — Concurrent::JavaThreadPoolExecutor
- #largest_length — Concurrent::RubyThreadPoolExecutor
- #latch — Concurrent::RubyExchanger::Node
- #leave_transaction — Concurrent
- #length — Concurrent::Collection::JavaNonConcurrentPriorityQueue
- #length — Concurrent::Collection::RubyNonConcurrentPriorityQueue
- #length — Concurrent::JavaThreadPoolExecutor
- #length — Concurrent::RubyThreadPoolExecutor
- #length — Concurrent::Synchronization::AbstractStruct
- #load_error_path — Concurrent::Utility::NativeExtensionLoader
- #load_native_extensions — Concurrent::Utility::NativeExtensionLoader
- #lock_and_clean_up_reverse_forwarders — Concurrent::Collection::AtomicReferenceMapBackend
- #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::ReadWriteLock
- #max_readers? — Concurrent::ReentrantReadWriteLock
- #max_writers? — Concurrent::ReadWriteLock
- #max_writers? — Concurrent::ReentrantReadWriteLock
- #members — Concurrent::Synchronization::AbstractStruct
- #merge — Concurrent::ImmutableStruct
- #merge — Concurrent::MutableStruct
- #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::Async::AsyncDelegator
- #method_missing — Concurrent::Async::AwaitDelegator
- #method_missing — Concurrent::SynchronizedDelegator
- #min_length — Concurrent::JavaThreadPoolExecutor
- #modify — Concurrent::MVar
- #modify! — Concurrent::MVar
- #monotonic_time — Concurrent
- #new — Concurrent::Async::ClassMethods
- #newThread — Concurrent::DaemonThreadFactory
- #new_condition — Concurrent::Synchronization::LockableObject
- #next_in_size_table — Concurrent::ThreadSafe::Util::PowerOfTwoTuple
- #next_index — Concurrent::RubyThreadLocalVar
- #no_error! — Concurrent::Concern::Obligation
- #nothing? — Concurrent::Maybe
- #notify_and_delete_observers — Concurrent::Collection::CopyOnNotifyObserverSet
- #notify_and_delete_observers — Concurrent::Collection::CopyOnWriteObserverSet
- #notify_child — Concurrent::Promise
- #notify_observers — Concurrent::Collection::CopyOnNotifyObserverSet
- #notify_observers — Concurrent::Collection::CopyOnWriteObserverSet
- #notify_observers — Concurrent::IVar
- #notify_to — Concurrent::Collection::CopyOnNotifyObserverSet
- #notify_to — Concurrent::Collection::CopyOnWriteObserverSet
- #ns_add_busy_worker — Concurrent::RubyThreadPoolExecutor
- #ns_assign_worker — Concurrent::RubyThreadPoolExecutor
- #ns_auto_terminate? — Concurrent::AbstractExecutorService
- #ns_broadcast — Concurrent::Synchronization::AbstractLockableObject
- #ns_broadcast — Concurrent::Synchronization::Condition
- #ns_broadcast — Concurrent::Synchronization::RbxLockableObject
- #ns_broadcast — Concurrent::Synchronization::ConditionSignalling
- #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::AbstractExecutorService
- #ns_execute — Concurrent::RubyThreadPoolExecutor
- #ns_find_last_job_for_thread — Concurrent::Agent
- #ns_generation_done — Concurrent::CyclicBarrier
- #ns_get — Concurrent::Synchronization::AbstractStruct
- #ns_initialize — Concurrent::Agent
- #ns_initialize — Concurrent::CyclicBarrier
- #ns_initialize — Concurrent::Event
- #ns_initialize — Concurrent::MutexAtomicBoolean
- #ns_initialize — Concurrent::MutexAtomicFixnum
- #ns_initialize — Concurrent::MutexCountDownLatch
- #ns_initialize — Concurrent::MutexSemaphore
- #ns_initialize — Concurrent::MutexAtomicReference
- #ns_initialize — Concurrent::Collection::CopyOnNotifyObserverSet
- #ns_initialize — Concurrent::Collection::CopyOnWriteObserverSet
- #ns_initialize — Concurrent::Delay
- #ns_initialize — Concurrent::CachedThreadPool
- #ns_initialize — Concurrent::JavaSingleThreadExecutor
- #ns_initialize — Concurrent::JavaThreadPoolExecutor
- #ns_initialize — Concurrent::RubyThreadPoolExecutor
- #ns_initialize — Concurrent::SerializedExecution
- #ns_initialize — Concurrent::SimpleExecutorService
- #ns_initialize — Concurrent::TimerSet
- #ns_initialize — Concurrent::Future
- #ns_initialize — Concurrent::IVar
- #ns_initialize — Concurrent::Promise
- #ns_initialize — Concurrent::TimerTask
- #ns_initialize — Concurrent::Synchronization::AbstractStruct
- #ns_initialize_copy — Concurrent::Synchronization::AbstractStruct
- #ns_inspect — Concurrent::Synchronization::AbstractStruct
- #ns_kill_execution — Concurrent::AbstractExecutorService
- #ns_kill_execution — Concurrent::RubyThreadPoolExecutor
- #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::RubyThreadPoolExecutor
- #ns_reset_if_forked — Concurrent::TimerSet
- #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::AbstractExecutorService
- #ns_shutdown_execution — Concurrent::RubyExecutorService
- #ns_shutdown_execution — Concurrent::RubyThreadPoolExecutor
- #ns_shutdown_execution — Concurrent::TimerSet
- #ns_shutdown_execution — Concurrent::TimerTask
- #ns_shuttingdown? — Concurrent::JavaExecutorService
- #ns_shuttingdown? — Concurrent::RubyExecutorService
- #ns_signal — Concurrent::Synchronization::AbstractLockableObject
- #ns_signal — Concurrent::Synchronization::Condition
- #ns_signal — Concurrent::Synchronization::RbxLockableObject
- #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::Condition
- #ns_wait — Concurrent::Synchronization::MutexLockableObject
- #ns_wait — Concurrent::Synchronization::MonitorLockableObject
- #ns_wait — Concurrent::Synchronization::RbxLockableObject
- #ns_wait_until — Concurrent::Synchronization::AbstractLockableObject
- #ns_wait_until — Concurrent::Synchronization::Condition
- #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::BlockedPromise
- #on_resolvable — Concurrent::Promises::ThenPromise
- #on_resolvable — Concurrent::Promises::RescuePromise
- #on_resolvable — Concurrent::Promises::ChainPromise
- #on_resolvable — Concurrent::Promises::AbstractFlatPromise
- #on_resolvable — Concurrent::Promises::ZipEventEventPromise
- #on_resolvable — Concurrent::Promises::ZipFutureEventPromise
- #on_resolvable — Concurrent::Promises::EventWrapperPromise
- #on_resolvable — Concurrent::Promises::FutureWrapperPromise
- #on_resolvable — Concurrent::Promises::ZipFuturesPromise
- #on_resolvable — Concurrent::Promises::ZipEventsPromise
- #on_resolvable — Concurrent::Promises::AnyResolvedEventPromise
- #on_resolvable — Concurrent::Promises::AnyResolvedFuturePromise
- #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::JavaNonConcurrentPriorityQueue
- #peek — Concurrent::LockFreeStack
- #peek — Concurrent::Collection::RubyNonConcurrentPriorityQueue
- #pending? — Concurrent::Promises::AbstractEventFuture
- #pending? — Concurrent::Concern::Obligation
- #perform — Concurrent::Async::AsyncDelegator
- #physical_processor_count — Concurrent::Utility::ProcessorCounter
- #pop — Concurrent::Collection::JavaNonConcurrentPriorityQueue
- #pop — Concurrent::LockFreeStack
- #pop — Concurrent::Collection::RubyNonConcurrentPriorityQueue
- #populate_from — Concurrent::Map
- #post — Concurrent::Agent
- #post — Concurrent::ImmediateExecutor
- #post — Concurrent::IndirectImmediateExecutor
- #post — Concurrent::JavaExecutorService
- #post — Concurrent::RubyExecutorService
- #post — Concurrent::SerializedExecution
- #post — Concurrent::SerializedExecutionDelegator
- #post — Concurrent::SimpleExecutorService
- #post — Concurrent::TimerSet
- #post — Concurrent::ExecutorService
- #post_task — Concurrent::TimerSet
- #posts — Concurrent::SerializedExecution
- #pr_underscore — Concurrent::Synchronization::AbstractStruct
- #process_on_blocker_resolution — Concurrent::Promises::BlockedPromise
- #process_on_blocker_resolution — Concurrent::Promises::FlatEventPromise
- #process_on_blocker_resolution — Concurrent::Promises::FlatFuturePromise
- #process_on_blocker_resolution — Concurrent::Promises::RunFuturePromise
- #process_on_blocker_resolution — Concurrent::Promises::ZipFutureEventPromise
- #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::LockFreeStack
- #push — Concurrent::Collection::RubyNonConcurrentPriorityQueue
- #put — Concurrent::Map
- #put — Concurrent::MVar
- #put_if_absent — Concurrent::Map
- #queue_length — Concurrent::JavaThreadPoolExecutor
- #queue_length — Concurrent::RubyThreadPoolExecutor
- #raise_fetch_no_key — Concurrent::Map
- #read — Concurrent::Transaction
- #ready_worker — Concurrent::RubyThreadPoolExecutor
- #realize — Concurrent::Promise
- #realized? — Concurrent::Concern::Obligation
- #reason — Concurrent::Agent
- #reason — Concurrent::Promises::InternalStates::ResolvedWithResult
- #reason — Concurrent::Promises::InternalStates::Fulfilled
- #reason — Concurrent::Promises::InternalStates::Rejected
- #reason — Concurrent::Promises::InternalStates::PartiallyRejected
- #reason — Concurrent::Promises::Future
- #reason — Concurrent::Promises::ResolvableFuture
- #reason — Concurrent::Concern::Obligation
- #rebuild — Concurrent::Collection::AtomicReferenceMapBackend
- #reconfigure — Concurrent::Delay
- #reduce_permits — Concurrent::MutexSemaphore
- #reject — Concurrent::Promises::ResolvableFuture
- #rejected? — Concurrent::Maybe
- #rejected? — Concurrent::Promises::Future
- #rejected? — Concurrent::Concern::Obligation
- #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::JavaThreadPoolExecutor
- #remaining_capacity — Concurrent::RubyThreadPoolExecutor
- #remove_busy_worker — Concurrent::RubyThreadPoolExecutor
- #remove_task — Concurrent::TimerSet
- #replace_if — Concurrent::LockFreeStack
- #replace_if_exists — Concurrent::Collection::AtomicReferenceMapBackend
- #replace_if_exists — Concurrent::Collection::MriMapBackend
- #replace_if_exists — Concurrent::Collection::NonConcurrentMapBackend
- #replace_if_exists — Concurrent::Collection::SynchronizedMapBackend
- #replace_pair — Concurrent::Collection::AtomicReferenceMapBackend
- #replace_pair — Concurrent::Collection::MriMapBackend
- #replace_pair — Concurrent::Collection::NonConcurrentMapBackend
- #replace_pair — Concurrent::Collection::SynchronizedMapBackend
- #reschedule — Concurrent::ScheduledTask
- #rescue — Concurrent::Promise
- #rescue — Concurrent::Promises::Future
- #rescue_on — Concurrent::Promises::Future
- #reset — Concurrent::Atom
- #reset — Concurrent::CyclicBarrier
- #reset — Concurrent::Event
- #reset — Concurrent::ScheduledTask
- #reset — Concurrent::ThreadSafe::Util::Adder
- #reset_if_forked — Concurrent::Async::AsyncDelegator
- #resolvable? — Concurrent::Promises::BlockedPromise
- #resolvable? — Concurrent::Promises::AbstractFlatPromise
- #resolvable? — Concurrent::Promises::AnyResolvedEventPromise
- #resolvable? — Concurrent::Promises::AnyResolvedFuturePromise
- #resolvable? — Concurrent::Promises::AnyFulfilledFuturePromise
- #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::AbstractEventFuture
- #resolve_with — Concurrent::Promises::AbstractPromise
- #resolved? — Concurrent::Promises::InternalStates::State
- #resolved? — Concurrent::Promises::InternalStates::Pending
- #resolved? — Concurrent::Promises::InternalStates::ResolvedWithResult
- #resolved? — Concurrent::Promises::AbstractEventFuture
- #resolved_event — Concurrent::Promises::FactoryMethods
- #resolved_future — Concurrent::Promises::FactoryMethods
- #respond_to_missing? — Concurrent::Async::AsyncDelegator
- #respond_to_missing? — Concurrent::Async::AwaitDelegator
- #restart — Concurrent::Agent
- #result — Concurrent::Promises::InternalStates::ResolvedWithResult
- #result — Concurrent::Promises::Future
- #result — Concurrent::Promises::ResolvableFuture
- #retry_update — Concurrent::ThreadSafe::Util::Striped64
- #ruby_engine — Concurrent::Utility::EngineDetector
- #ruby_version — Concurrent::Utility::EngineDetector
- #run — Concurrent::JavaExecutorService::Job
- #run — Concurrent::Promises::Future
- #run_task — Concurrent::RubyThreadPoolExecutor::Worker
- #run_test — Concurrent::Promises::Future
- #running? — Concurrent::AbstractExecutorService
- #running? — Concurrent::ImmediateExecutor
- #running? — Concurrent::JavaThreadPoolExecutor
- #running? — Concurrent::SimpleExecutorService
- #running? — Concurrent::TimerTask
- #running_readers — Concurrent::ReadWriteLock
- #running_readers — Concurrent::ReentrantReadWriteLock
- #running_readers? — Concurrent::ReadWriteLock
- #running_readers? — Concurrent::ReentrantReadWriteLock
- #running_writer? — Concurrent::ReadWriteLock
- #running_writer? — Concurrent::ReentrantReadWriteLock
- #safe_execute — Concurrent::IVar
- #schedule — Concurrent::Promises::Event
- #schedule — Concurrent::Promises::Future
- #schedule — Concurrent::Promises::FactoryMethods
- #schedule_next_task — Concurrent::TimerTask
- #schedule_on — Concurrent::Promises::FactoryMethods
- #schedule_time — Concurrent::ScheduledTask
- #scheduled_task_count — Concurrent::JavaThreadPoolExecutor
- #scheduled_task_count — Concurrent::RubyThreadPoolExecutor
- #select — Concurrent::ImmutableStruct
- #select — Concurrent::MutableStruct
- #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::ExecutorService
- #serialized? — Concurrent::SerialExecutorService
- #set — Concurrent::AtomicMarkableReference
- #set — Concurrent::Event
- #set — Concurrent::MutexAtomicReference
- #set — Concurrent::Future
- #set — Concurrent::IVar
- #set — Concurrent::Promise
- #set — Concurrent::Tuple
- #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::JavaNonConcurrentPriorityQueue
- #shift — Concurrent::Collection::RubyNonConcurrentPriorityQueue
- #shutdown — Concurrent::AbstractExecutorService
- #shutdown — Concurrent::ImmediateExecutor
- #shutdown — Concurrent::JavaExecutorService
- #shutdown — Concurrent::RubyExecutorService
- #shutdown — Concurrent::SimpleExecutorService
- #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::Collection::JavaNonConcurrentPriorityQueue
- #size — Concurrent::Collection::AtomicReferenceMapBackend
- #size — Concurrent::Collection::NonConcurrentMapBackend
- #size — Concurrent::Collection::SynchronizedMapBackend
- #size — Concurrent::Collection::RubyNonConcurrentPriorityQueue
- #size — Concurrent::Map
- #size — Concurrent::Synchronization::AbstractStruct
- #split_bin — Concurrent::Collection::AtomicReferenceMapBackend
- #split_old_bin — Concurrent::Collection::AtomicReferenceMapBackend
- #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::MutexAtomicReference
- #swap — Concurrent::Collection::RubyNonConcurrentPriorityQueue
- #swim — Concurrent::Collection::RubyNonConcurrentPriorityQueue
- #synchronize — Concurrent::MVar
- #synchronize — Concurrent::Synchronization::AbstractLockableObject
- #synchronize — Concurrent::Synchronization::MutexLockableObject
- #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
- #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::ImmutableStruct
- #to_a — Concurrent::MutableStruct
- #to_a — Concurrent::SettableStruct
- #to_event — Concurrent::Promises::Event
- #to_event — Concurrent::Promises::Future
- #to_future — Concurrent::Promises::Event
- #to_future — Concurrent::Promises::Future
- #to_h — Concurrent::ImmutableStruct
- #to_h — Concurrent::MutableStruct
- #to_h — Concurrent::SettableStruct
- #to_s — Concurrent::AtomicBoolean
- #to_s — Concurrent::AtomicFixnum
- #to_s — AtomicReference
- #to_s — Concurrent::LockFreeStack
- #to_s — Concurrent::AbstractExecutorService
- #to_s — Concurrent::Promises::AbstractEventFuture
- #to_s — Concurrent::Promises::Future
- #to_s — Concurrent::Promises::AbstractPromise
- #to_s — Concurrent::ImmutableStruct
- #to_s — Concurrent::MutableStruct
- #to_s — Concurrent::SettableStruct
- #to_sym — Concurrent::Promises::InternalStates::State
- #to_sym — Concurrent::Promises::InternalStates::Pending
- #to_sym — Concurrent::Promises::InternalStates::ResolvedWithResult
- #to_sym — Concurrent::Promises::InternalStates::Fulfilled
- #to_sym — Concurrent::Promises::InternalStates::Rejected
- #to_sym — Concurrent::Promises::InternalStates::PartiallyRejected
- #touch — Concurrent::Promises::AbstractEventFuture
- #touch — Concurrent::Promises::AbstractPromise
- #touch — Concurrent::Promises::BlockedPromise
- #touch — Concurrent::Promises::AbstractFlatPromise
- #touch — Concurrent::Promises::DelayPromise
- #touched? — Concurrent::Promises::AbstractEventFuture
- #touched? — Concurrent::Promises::AbstractFlatPromise
- #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::AtomicReferenceMapBackend
- #try_initialize_cells — Concurrent::ThreadSafe::Util::Striped64
- #try_load_c_extension — Concurrent::Utility::NativeExtensionLoader
- #try_lock_via_hash — Concurrent::Collection::AtomicReferenceMapBackend::Table
- #try_lock_via_hash — Concurrent::Collection::AtomicReferenceMapBackend::Node
- #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::AtomicMarkableReference
- #try_update! — Concurrent::AtomicDirectUpdate
- #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::AtomicMarkableReference
- #update — Concurrent::MutexAtomicFixnum
- #update — Concurrent::AtomicDirectUpdate
- #valid? — Concurrent::Atom
- #valid? — Concurrent::Transaction
- #validate_options_hash! — Concurrent::Map
- #value — Concurrent::Agent
- #value — Concurrent::AbstractThreadLocalVar
- #value — Concurrent::AtomicMarkableReference
- #value — Concurrent::JavaThreadLocalVar
- #value — Concurrent::MutexAtomicBoolean
- #value — Concurrent::MutexAtomicFixnum
- #value — Concurrent::RubyThreadLocalVar
- #value — Concurrent::MutexAtomicReference
- #value — Concurrent::Delay
- #value — Concurrent::Promises::InternalStates::ResolvedWithResult
- #value — Concurrent::Promises::InternalStates::Fulfilled
- #value — Concurrent::Promises::InternalStates::Rejected
- #value — Concurrent::Promises::InternalStates::PartiallyRejected
- #value — Concurrent::Promises::Future
- #value — Concurrent::Promises::ResolvableFuture
- #value — Concurrent::TVar
- #value — Concurrent::Concern::Dereferenceable
- #value — Concurrent::Concern::Obligation
- #value! — Concurrent::Delay
- #value! — Concurrent::Promises::Future
- #value! — Concurrent::Promises::ResolvableFuture
- #value! — Concurrent::Concern::Obligation
- #value= — Concurrent::AbstractThreadLocalVar
- #value= — Concurrent::JavaThreadLocalVar
- #value= — Concurrent::MutexAtomicBoolean
- #value= — Concurrent::MutexAtomicFixnum
- #value= — Concurrent::RubyThreadLocalVar
- #value= — Concurrent::MutexAtomicReference
- #value= — Concurrent::TVar
- #value= — Concurrent::Concern::Dereferenceable
- #value? — Concurrent::Map
- #value_for — Concurrent::RubyThreadLocalVar
- #values — Concurrent::Map
- #values — Concurrent::ImmutableStruct
- #values — Concurrent::MutableStruct
- #values — Concurrent::SettableStruct
- #values_at — Concurrent::ImmutableStruct
- #values_at — Concurrent::MutableStruct
- #values_at — Concurrent::SettableStruct
- #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::Agent
- #wait — Concurrent::CyclicBarrier
- #wait — Concurrent::Event
- #wait — Concurrent::JavaCountDownLatch
- #wait — Concurrent::MutexCountDownLatch
- #wait — Concurrent::Delay
- #wait — Concurrent::Promises::AbstractEventFuture
- #wait — Concurrent::Promises::ResolvableEvent
- #wait — Concurrent::Promises::ResolvableFuture
- #wait — Concurrent::Synchronization::Condition
- #wait — Concurrent::Synchronization::Lock
- #wait — Concurrent::Concern::Obligation
- #wait! — Concurrent::Promises::Future
- #wait! — Concurrent::Promises::ResolvableFuture
- #wait! — Concurrent::Concern::Obligation
- #wait_for_empty — Concurrent::MVar
- #wait_for_full — Concurrent::MVar
- #wait_for_termination — Concurrent::AbstractExecutorService
- #wait_for_termination — Concurrent::ImmediateExecutor
- #wait_for_termination — Concurrent::JavaExecutorService
- #wait_for_termination — Concurrent::RubyExecutorService
- #wait_for_termination — Concurrent::SimpleExecutorService
- #wait_or_cancel — Concurrent::Future
- #wait_until — Concurrent::Synchronization::Condition
- #wait_until — Concurrent::Synchronization::Lock
- #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::AbstractEventFuture
- #with_default_executor — Concurrent::Promises::Event
- #with_default_executor — Concurrent::Promises::Future
- #with_hidden_resolvable — Concurrent::Promises::AbstractEventFuture
- #with_hidden_resolvable — Concurrent::Promises::ResolvableEvent
- #with_hidden_resolvable — Concurrent::Promises::ResolvableFuture
- #with_observer — Concurrent::Concern::Observable
- #with_read_lock — Concurrent::ReadWriteLock
- #with_read_lock — Concurrent::ReentrantReadWriteLock
- #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
- #xorshift — Concurrent::ThreadSafe::Util::XorShiftRandom
- #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