Table of Contents - concurrent-ruby-1.0.4 Documentation
Pages
-
CHANGELOG
- Current Release v1.0.4 (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
- Supported Ruby versions
- Thread Safety
- Features & Documentation
- General-purpose Concurrency Abstractions
- Thread-safe Value Objects, Structures, and Collections
- Java-inspired ThreadPools and Other Executors
- Thread Synchronization Classes and Algorithms
- Edge Features
- Statuses:
- Usage
- Installation
- Edge Gem Installation
- C Extensions for MRI
- Note For gem developers
- Maintainers
- Special Thanks
- License and Copyright
Classes and Modules
- Concurrent
- Concurrent::AbstractExchanger
- Concurrent::AbstractExecutorService
- Concurrent::AbstractThreadLocalVar
- Concurrent::Agent
- Concurrent::Agent::Error
- Concurrent::Agent::ValidationError
- Concurrent::Array
- Concurrent::Async
- Concurrent::Async::AsyncDelegator
- Concurrent::Async::AwaitDelegator
- Concurrent::Async::ClassMethods
- Concurrent::AtExitImplementation
- Concurrent::Atom
- Concurrent::AtomicBoolean
- Concurrent::AtomicDirectUpdate
- Concurrent::AtomicFixnum
- Concurrent::AtomicNumericCompareAndSetWrapper
- Concurrent::AtomicReference
- Concurrent::CAtomicReference
- 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::Edge
- Concurrent::Event
- Concurrent::Exchanger
- Concurrent::ExecutorService
- Concurrent::FixedThreadPool
- Concurrent::Future
- Concurrent::Hash
- 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::LazyRegister
- 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::RbxAtomicReference
- 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::JRubyAttrVolatile
- Concurrent::Synchronization::JRubyAttrVolatile::ClassMethods
- Concurrent::Synchronization::JRubyLockableObject
- Concurrent::Synchronization::JRubyObject
- Concurrent::Synchronization::Lock
- Concurrent::Synchronization::LockableObject
- Concurrent::Synchronization::MriAttrVolatile
- Concurrent::Synchronization::MriAttrVolatile::ClassMethods
- Concurrent::Synchronization::MriLockableObject
- Concurrent::Synchronization::MriMonitorLockableObject
- Concurrent::Synchronization::MriMutexLockableObject
- Concurrent::Synchronization::MriObject
- Concurrent::Synchronization::Object
- Concurrent::Synchronization::RbxAttrVolatile
- Concurrent::Synchronization::RbxAttrVolatile::ClassMethods
- Concurrent::Synchronization::RbxLockableObject
- Concurrent::Synchronization::RbxObject
- Concurrent::Synchronization::TruffleAttrVolatile
- Concurrent::Synchronization::TruffleAttrVolatile::ClassMethods
- Concurrent::Synchronization::TruffleLockableObject
- Concurrent::Synchronization::TruffleObject
- 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::Tuple
- Concurrent::Utility
- Concurrent::Utility::EngineDetector
- Concurrent::Utility::NativeExtensionLoader
- Concurrent::Utility::NativeInteger
- Concurrent::Utility::ProcessorCounter
Methods
- ::<< — Concurrent::SimpleExecutorService
- ::abort_transaction — Concurrent
- ::aggregate — Concurrent::Promise
- ::all? — Concurrent::Promise
- ::allocate — Concurrent::ThreadSafe::Util
- ::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::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::TruffleAttrVolatile
- ::just — Concurrent::Maybe
- ::leave_transaction — Concurrent
- ::locked_hash? — Concurrent::Collection::AtomicReferenceMapBackend::Node
- ::make_synchronized_on_rbx — 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::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::Collection::AtomicReferenceMapBackend
- ::new — Concurrent::Collection::AtomicReferenceMapBackend::Node
- ::new — Concurrent::Collection::MriMapBackend
- ::new — Concurrent::Collection::NonConcurrentMapBackend
- ::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
- ::new — Concurrent::JavaExecutorService::Job
- ::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::LazyRegister
- ::new — Concurrent::Map
- ::new — Concurrent::Maybe
- ::new — Concurrent::MVar
- ::new — Concurrent::Promise
- ::new — Concurrent::ScheduledTask
- ::new — Concurrent::Synchronization::AbstractObject
- ::new — Concurrent::Synchronization::Condition
- ::new — Concurrent::Synchronization::JRubyObject
- ::new — Concurrent::Synchronization::MriMutexLockableObject
- ::new — Concurrent::Synchronization::MriMonitorLockableObject
- ::new — Concurrent::Synchronization::MriObject
- ::new — Concurrent::Synchronization::Object
- ::new — Concurrent::Synchronization::Object
- ::new — Concurrent::Synchronization::RbxLockableObject
- ::new — Concurrent::Synchronization::RbxObject
- ::new — Concurrent::Synchronization::TruffleObject
- ::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::AtExitImplementation
- ::new — Concurrent::Utility::ProcessorCounter
- ::new — Concurrent
- ::new — Concurrent::ImmutableStruct
- ::new — Concurrent::MutableStruct
- ::new — Concurrent::SettableStruct
- ::new — Concurrent::Synchronization::AbstractStruct
- ::new_fast_executor — Concurrent
- ::new_io_executor — Concurrent
- ::nothing — Concurrent::Maybe
- ::physical_processor_count — Concurrent
- ::post — Concurrent::SimpleExecutorService
- ::processor_count — Concurrent
- ::reject — Concurrent::Promise
- ::safe_initialization! — Concurrent::Synchronization::Object
- ::safe_initialization? — Concurrent::Synchronization::Object
- ::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::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::LazyRegister
- #[] — Concurrent::Map
- #[] — Concurrent::ImmutableStruct
- #[] — Concurrent::MutableStruct
- #[] — Concurrent::SettableStruct
- #[]= — Concurrent::Collection::AtomicReferenceMapBackend
- #[]= — Concurrent::Collection::MriMapBackend
- #[]= — Concurrent::Collection::NonConcurrentMapBackend
- #[]= — Concurrent::Collection::SynchronizedMapBackend
- #[]= — Concurrent::MutableStruct
- #[]= — Concurrent::SettableStruct
- #_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::LazyRegister
- #add — Concurrent::ThreadSafe::Util::Adder
- #add — Concurrent::AtExitImplementation
- #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
- #apply_deref_options — Concurrent::Concern::Dereferenceable
- #async — Concurrent::Async
- #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::TruffleAttrVolatile::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
- #borrow — Concurrent::MVar
- #broadcast — Concurrent::Synchronization::Condition
- #broadcast — Concurrent::Synchronization::Lock
- #broken? — Concurrent::CyclicBarrier
- #c_extensions_loaded? — Concurrent::Utility::NativeExtensionLoader
- #call — Concurrent::Async
- #call_dataflow — Concurrent
- #call_job — Concurrent::SerializedExecution
- #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
- #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::Collection::AtomicReferenceMapBackend
- #clear — Concurrent::Collection::MriMapBackend
- #clear — Concurrent::Collection::NonConcurrentMapBackend
- #clear — Concurrent::Collection::SynchronizedMapBackend
- #clear — Concurrent::Collection::RubyNonConcurrentPriorityQueue
- #clear_observers_and_return_old — Concurrent::Collection::CopyOnWriteObserverSet
- #commit — Concurrent::Transaction
- #compare_and_set — Concurrent::Atom
- #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::AtomicNumericCompareAndSetWrapper
- #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
- #default — Concurrent::AbstractThreadLocalVar
- #default_for — Concurrent::RubyThreadLocalVar
- #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 — Concurrent::LazyRegister
- #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::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::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::ImmutableStruct
- #each_pair — Concurrent::MutableStruct
- #each_pair — Concurrent::SettableStruct
- #each_value — Concurrent::Map
- #empty? — Concurrent::Collection::JavaNonConcurrentPriorityQueue
- #empty? — Concurrent::Collection::AtomicReferenceMapBackend
- #empty? — Concurrent::Collection::RubyNonConcurrentPriorityQueue
- #empty? — Concurrent::Map
- #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
- #event — Concurrent::Concern::Obligation
- #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
- #expand_table_unless_stale — Concurrent::ThreadSafe::Util::Striped64
- #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_map — Concurrent::Promise
- #force_aquire_lock — Concurrent::Collection::AtomicReferenceMapBackend::Node
- #free? — Concurrent::ThreadSafe::Util::Striped64
- #fulfilled? — Concurrent::Maybe
- #fulfilled? — Concurrent::Concern::Obligation
- #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::TruffleAttrVolatile
- #get — Concurrent::MutexAtomicReference
- #get — Concurrent::Map
- #get — Concurrent::Tuple
- #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_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
- #handler? — Concurrent::AtExitImplementation
- #handlers — Concurrent::AtExitImplementation
- #has_key? — Concurrent::LazyRegister
- #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
- #include? — Concurrent::Collection::JavaNonConcurrentPriorityQueue
- #include? — Concurrent::Collection::RubyNonConcurrentPriorityQueue
- #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::MultipleAssignmentError
- #inspect — Concurrent::Map
- #inspect — Concurrent::ImmutableStruct
- #inspect — Concurrent::MutableStruct
- #inspect — Concurrent::SettableStruct
- #install — Concurrent::AtExitImplementation
- #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? — Concurrent::LazyRegister
- #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_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_true — Concurrent::MutexAtomicBoolean
- #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::Synchronization::TruffleLockableObject
- #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::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_auto_terminate? — Concurrent::AbstractExecutorService
- #ns_broadcast — Concurrent::Synchronization::AbstractLockableObject
- #ns_broadcast — Concurrent::Synchronization::Condition
- #ns_broadcast — Concurrent::Synchronization::MriLockableObject
- #ns_broadcast — Concurrent::Synchronization::RbxLockableObject
- #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::AtExitImplementation
- #ns_initialize — 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_executor_runnable — Concurrent::JavaExecutorService
- #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::MriLockableObject
- #ns_signal — Concurrent::Synchronization::RbxLockableObject
- #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::MriMutexLockableObject
- #ns_wait — Concurrent::Synchronization::MriMonitorLockableObject
- #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_cruby? — Concurrent::Utility::EngineDetector
- #on_error — Concurrent::Promise
- #on_fulfill — Concurrent::Promise
- #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_success — Concurrent::Promise
- #on_truffle? — 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::Collection::RubyNonConcurrentPriorityQueue
- #pending? — Concurrent::Concern::Obligation
- #perform — Concurrent::Async::AsyncDelegator
- #physical_processor_count — Concurrent::Utility::ProcessorCounter
- #pop — Concurrent::Collection::JavaNonConcurrentPriorityQueue
- #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_task — Concurrent::ScheduledTask
- #process_tasks — Concurrent::TimerSet
- #processing? — Concurrent::ScheduledTask
- #processor_count — Concurrent::Utility::ProcessorCounter
- #pure_hash — Concurrent::Collection::AtomicReferenceMapBackend::Node
- #push — Concurrent::Collection::JavaNonConcurrentPriorityQueue
- #push — Concurrent::Collection::RubyNonConcurrentPriorityQueue
- #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::Concern::Obligation
- #rebuild — Concurrent::Collection
- #reconfigure — Concurrent::Delay
- #reduce_permits — Concurrent::MutexSemaphore
- #register — Concurrent::LazyRegister
- #registered? — Concurrent::LazyRegister
- #rejected? — Concurrent::Maybe
- #rejected? — Concurrent::Concern::Obligation
- #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 — Concurrent::LazyRegister
- #remove_busy_worker — Concurrent::RubyThreadPoolExecutor
- #remove_task — Concurrent::TimerSet
- #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
- #reset — Concurrent::Atom
- #reset — Concurrent::CyclicBarrier
- #reset — Concurrent::Event
- #reset — Concurrent::ScheduledTask
- #reset — Concurrent::ThreadSafe::Util::Adder
- #restart — Concurrent::Agent
- #retry_update — Concurrent::ThreadSafe::Util::Striped64
- #ruby_engine — Concurrent::Utility::EngineDetector
- #ruby_version — Concurrent::Utility::EngineDetector
- #run — Concurrent::JavaExecutorService::Job
- #run — Concurrent::AtExitImplementation
- #run_task — Concurrent::RubyThreadPoolExecutor::Worker
- #runner — Concurrent::AtExitImplementation
- #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_next_task — Concurrent::TimerTask
- #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::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
- #split_old_bin — Concurrent::Collection
- #state — Concurrent::Concern::Obligation
- #state= — Concurrent::Concern::Obligation
- #stop — Concurrent::RubyThreadPoolExecutor::Worker
- #stop_event — Concurrent::RubyExecutorService
- #stopped? — Concurrent::Agent
- #stopped_event — Concurrent::RubyExecutorService
- #store — Concurrent::LazyRegister
- #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::MriMutexLockableObject
- #synchronize — Concurrent::Synchronization::MriMonitorLockableObject
- #synchronize — Concurrent::Synchronization::RbxLockableObject
- #synchronized_set_state! — Concurrent::Promise
- #table_size_for — Concurrent::Collection::AtomicReferenceMapBackend
- #take — Concurrent::MVar
- #teardown — Concurrent::SynchronizedDelegator
- #terminate_at_exit — Concurrent::AbstractExecutorService
- #then — Concurrent::Promise
- #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_h — Concurrent::ImmutableStruct
- #to_h — Concurrent::MutableStruct
- #to_h — Concurrent::SettableStruct
- #to_s — Concurrent::AtomicFixnum
- #to_s — Concurrent::AtomicReference
- #to_s — Concurrent::ImmutableStruct
- #to_s — Concurrent::MutableStruct
- #to_s — Concurrent::SettableStruct
- #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_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::AtomicDirectUpdate
- #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
- #unregister — Concurrent::LazyRegister
- #unscheduled? — Concurrent::Concern::Obligation
- #up — Concurrent::MutexAtomicFixnum
- #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::JavaThreadLocalVar
- #value — Concurrent::MutexAtomicBoolean
- #value — Concurrent::MutexAtomicFixnum
- #value — Concurrent::RubyThreadLocalVar
- #value — Concurrent::MutexAtomicReference
- #value — Concurrent::Delay
- #value — Concurrent::TVar
- #value — Concurrent::Concern::Dereferenceable
- #value — Concurrent::Concern::Obligation
- #value! — Concurrent::Delay
- #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::Synchronization::Condition
- #wait — Concurrent::Synchronization::Lock
- #wait — Concurrent::Concern::Obligation
- #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_while — Concurrent::MVar
- #waiting_or_running_writer? — Concurrent::ReentrantReadWriteLock
- #waiting_writer? — Concurrent::ReadWriteLock
- #waiting_writers — Concurrent::ReadWriteLock
- #waiting_writers — Concurrent::ReentrantReadWriteLock
- #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
- #zip — Concurrent::Promise