Skip to content

Upgrading concurrent-ruby 0.9 to 1

Breaking0.9.2 → 1.3.8Breaking1Security3New6Changed7Fixed12Other23

Fetching 38 releases from GitHub…10 / 38
BreakingUpgrade verdict

1 breaking change and 3 security fixes.

  • Removes AtomicReferenceMapBackend and CheapLockable.
  • Updating a shared atomic value could hang forever if that value was NaN (not-a-number). This is now fixed.
  • Under heavy read locking, the lock could wrongly hand out a write lock to more than one thread at once. This is now fixed.
  • A lock could be released by a thread that did not hold it, and releasing reads incorrectly could corrupt the lock's counters. This is now fixed.
4 items need code or config changes

Ruby requirement changed in 1.2.0: >= 1.9.3 → >= 2.3.

Breaking1
Removes AtomicReferenceMapBackend and CheapLockable.
AtomicReferenceMapBackendCheapLockable
Security3
Fixes CVE-2026-54904 where AtomicReference#update livelocks when the stored value is Float::NAN.
AtomicReference#updateFloat::NANHigh · CVSS 7.5
Fixes CVE-2026-54905 where ReentrantReadWriteLock read-count overflow grants a write lock without exclusivity.
ReentrantReadWriteLockLow · CVSS 5.5
Fixes CVE-2026-54906 where ReadWriteLock allows wrong-thread write release and stray read-release counter corruption.
ReadWriteLockLow

Generated by DepDelta from published Ruby source. Not mixed with prose notes.

  • removed: const Concurrent.Atomic
  • removed: const Concurrent.EDGE_VERSION
  • removed: static method Concurrent.configuration()
  • removed: static method Concurrent.configure()
  • removed: static method Concurrent.disable_executor_auto_termination!()
  • removed: static method Concurrent.disable_executor_auto_termination?()
  • removed: static method Concurrent.terminate_pools!()
  • removed: static method Concurrent.timeout(_)
  • removed: static method Concurrent.timer(_, *)
  • changed: static method Concurrent.monotonic_time() → static method Concurrent.monotonic_time(_ = …)
  • added: const Concurrent.LockLocalVar
  • added: const TruffleRuby.AtomicReference
  • added: module TruffleRuby
  • added: static method Concurrent.available_processor_count()
  • added: static method Concurrent.cpu_quota()
  • added: static method Concurrent.cpu_shares()
  • added: static method Concurrent.create_simple_logger(_ = …, _ = …)
  • added: static method Concurrent.mutex_owned_per_thread?()
  • added: static method Concurrent.use_simple_logger(_ = …, _ = …)
  • added: static method TruffleRuby.synchronized(_)
  • removed: class AbstractThreadLocalVar
  • removed: class AtExit < AtExitImplementation.new
  • removed: class Condition
  • removed: class Configuration
  • removed: class JavaThreadLocalVar < AbstractThreadLocalVar
  • removed: class LazyRegister
  • removed: class PerThreadExecutor < SimpleExecutorService
  • removed: class PureCountDownLatch < Synchronization::Object
  • removed: class RbxAtomicReference < Rubinius::AtomicReference
  • removed: class RubyThreadLocalVar < AbstractThreadLocalVar
  • removed: const MutexAtomicFixnum.MAX_VALUE
  • removed: const MutexAtomicFixnum.MIN_VALUE
  • removed: const TimerTask.TIMEOUT_INTERVAL
  • removed: constructor AbstractThreadLocalVar(_ = …)
  • removed: constructor Condition()
  • removed: constructor Configuration()
  • removed: constructor Exchanger(_ = …)
  • removed: constructor JavaExecutorService(*)
  • removed: constructor LazyRegister()
  • removed: constructor PerThreadExecutor()
  • removed: constructor PureCountDownLatch(_ = …)
  • removed: constructor RubyThreadLocalVar(_ = …)
  • removed: method AbstractThreadLocalVar.bind(_)
  • removed: method AbstractThreadLocalVar.value()
  • removed: method Async.init_mutex()
  • removed: method Atom.value()
  • removed: method Condition.broadcast()
  • removed: method Condition.signal()
  • removed: method Condition.wait(_, _ = …)
  • removed: method Configuration.auto_terminate()
  • removed: method Configuration.global_operation_pool()
  • removed: method Configuration.global_task_pool()
  • removed: method Configuration.global_timer_set()
  • removed: method Configuration.logger()
  • removed: method Configuration.new_operation_pool()
  • removed: method Configuration.new_task_pool()
  • removed: method Configuration.no_logger()
  • removed: method Exchanger.exchange(_, _ = …)
  • removed: method JavaThreadLocalVar.bind(_)
  • removed: method JavaThreadLocalVar.value()
  • removed: method LazyRegister.[](_)
  • removed: method LazyRegister.add(_)
  • removed: method LazyRegister.delete(_)
  • removed: method LazyRegister.has_key?(_)
  • removed: method LazyRegister.key?(_)
  • removed: method LazyRegister.register(_)
  • removed: method LazyRegister.registered?(_)
  • removed: method LazyRegister.remove(_)
  • removed: method LazyRegister.store(_)
  • removed: method LazyRegister.unregister(_)
  • removed: method MutexAtomicReference._compare_and_set(_, _)
  • removed: method PureCountDownLatch.count()
  • removed: method PureCountDownLatch.count_down()
  • removed: method PureCountDownLatch.wait(_ = …)
  • removed: method RbxAtomicReference._compare_and_set()
  • removed: method RbxAtomicReference.swap()
  • removed: method RbxAtomicReference.value()
  • removed: method RbxAtomicReference.value=()
  • removed: method RubyThreadLocalVar.bind(_)
  • removed: method RubyThreadLocalVar.value()
  • removed: method RubyThreadPoolExecutor.remove_busy_worker(_)
  • removed: method RubyThreadPoolExecutor.worker_not_old_enough(_)
  • removed: method ScheduledTask.delay()
  • removed: method ScheduledTask.in_progress?()
  • removed: method ScheduledTask.stop()
  • removed: method TVar.unsafe_increment_version()
  • removed: method TVar.unsafe_version()
  • removed: method Transaction.valid?()
  • removed: module Edge
  • removed: module Executor
  • removed: property RubyThreadPoolExecutor.completed_task_count: reader
  • removed: property RubyThreadPoolExecutor.largest_length: reader
  • removed: property RubyThreadPoolExecutor.scheduled_task_count: reader
  • removed: protected method AbstractExecutorService.execute(*)
  • removed: protected method AbstractExecutorService.handle_fallback(*)
  • removed: protected method AbstractExecutorService.kill_execution()
  • removed: protected method AbstractExecutorService.ns_auto_terminate?()
  • removed: protected method AbstractExecutorService.shutdown_execution()
  • removed: protected method AbstractExecutorService.terminate_at_exit()
  • removed: protected method AbstractThreadLocalVar.allocate_storage()
  • removed: protected method JavaExecutorService.ns_make_executor_runnable()
  • removed: protected method JavaExecutorService.ns_running?()
  • removed: protected method JavaExecutorService.ns_shutdown?()
  • removed: protected method JavaExecutorService.ns_shuttingdown?()
  • removed: protected method JavaSingleThreadExecutor.ns_initialize(_)
  • removed: protected method JavaThreadLocalVar.allocate_storage()
  • removed: protected method JavaThreadPoolExecutor.ns_initialize(_)
  • removed: protected method MutexAtomicBoolean.ns_initialize(_)
  • removed: protected method MutexAtomicBoolean.ns_make_value(_)
  • removed: protected method MutexAtomicFixnum.ns_initialize(_)
  • removed: protected method PureCountDownLatch.ns_initialize(_)
  • removed: protected method RubyExecutorService.ns_running?()
  • removed: protected method RubyExecutorService.ns_shutdown?()
  • removed: protected method RubyExecutorService.ns_shuttingdown?()
  • removed: protected method RubyExecutorService.shutdown_execution()
  • removed: protected method RubySingleThreadExecutor.alive?()
  • removed: protected method RubySingleThreadExecutor.execute(*)
  • removed: protected method RubySingleThreadExecutor.kill_execution()
  • removed: protected method RubySingleThreadExecutor.new_worker_thread()
  • removed: protected method RubySingleThreadExecutor.ns_initialize(_)
  • removed: protected method RubySingleThreadExecutor.shutdown_execution()
  • removed: protected method RubySingleThreadExecutor.supervise()
  • removed: protected method RubySingleThreadExecutor.work()
  • removed: protected method RubyThreadLocalVar.allocate_storage()
  • removed: protected method RubyThreadPoolExecutor.execute(*)
  • removed: protected method RubyThreadPoolExecutor.kill_execution()
  • removed: protected method RubyThreadPoolExecutor.ns_add_busy_worker()
  • removed: protected method RubyThreadPoolExecutor.ns_assign_worker(*)
  • removed: protected method RubyThreadPoolExecutor.ns_enqueue(*)
  • removed: protected method RubyThreadPoolExecutor.ns_execute(*)
  • removed: protected method RubyThreadPoolExecutor.ns_initialize(_)
  • removed: protected method RubyThreadPoolExecutor.ns_kill_execution()
  • removed: protected method RubyThreadPoolExecutor.ns_limited_queue?()
  • removed: protected method RubyThreadPoolExecutor.ns_prune_pool()
  • removed: protected method RubyThreadPoolExecutor.ns_ready_worker(_, _ = …)
  • removed: protected method RubyThreadPoolExecutor.ns_remove_busy_worker(_)
  • removed: protected method RubyThreadPoolExecutor.ns_shutdown_execution()
  • removed: protected method RubyThreadPoolExecutor.ns_worker_died(_)
  • removed: protected method RubyThreadPoolExecutor.ns_worker_not_old_enough(_)
  • removed: protected method RubyThreadPoolExecutor.shutdown_execution()
  • removed: protected method ScheduledTask.calculate_delay!(_)
  • removed: protected method SerializedExecution.call_job(_)
  • removed: protected method SerializedExecution.ns_initialize()
  • removed: protected method SerializedExecution.work(_)
  • removed: protected method SimpleExecutorService.ns_initialize()
  • removed: protected method TimerSet.ns_initialize(_)
  • removed: protected method TimerSet.ns_post_task(_)
  • removed: protected method TimerSet.post_task(_)
  • removed: protected method TimerSet.process_tasks()
  • removed: protected method TimerSet.remove_task(_)
  • removed: protected method TimerSet.shutdown_execution()
  • removed: protected method TimerTask.execute_task(_)
  • removed: protected method TimerTask.kill_execution()
  • removed: protected method TimerTask.ns_initialize(_)
  • removed: protected method TimerTask.schedule_next_task(_ = …)
  • removed: protected method TimerTask.shutdown_execution()
  • removed: protected method TimerTask.timeout_task(_)
  • removed: protected property RubyExecutorService.stop_event: reader
  • removed: protected property RubyExecutorService.stopped_event: reader
  • removed: protected set AbstractExecutorService.ns_auto_terminate(_)
  • removed: protected static method RubyThreadLocalVar.thread_finalizer(_)
  • removed: protected static method RubyThreadLocalVar.threadlocal_finalizer(_)
  • removed: set AbstractThreadLocalVar.value(_)
  • removed: set Async.executor(_)
  • removed: set Configuration.auto_terminate(_)
  • removed: set Configuration.global_operation_pool(_)
  • removed: set Configuration.global_task_pool(_)
  • removed: set Configuration.logger(_)
  • removed: set JavaThreadLocalVar.value(_)
  • removed: set RubyThreadLocalVar.value(_)
  • removed: static method Executor.executor(_)
  • removed: static method Executor.executor_from_options(_ = …)
  • removed: static method ImmutableStruct.new(*)
  • removed: static method MutableStruct.new(*)
  • removed: static method SettableStruct.new(*)
  • changed: class AbstractExecutorService < Synchronization::Object → class AbstractExecutorService < Synchronization::LockableObject
  • changed: class AtomicReference < Concurrent::JavaAtomicReference → class AtomicReference < AtomicReferenceImplementation
  • changed: class CountDownLatch < JavaCountDownLatch → class CountDownLatch < CountDownLatchImplementation
  • changed: class CyclicBarrier < Synchronization::Object → class CyclicBarrier < Synchronization::LockableObject
  • changed: class Delay < Synchronization::Object → class Delay < Synchronization::LockableObject
  • changed: class Event < Synchronization::Object → class Event < Synchronization::LockableObject
  • changed: class Exchanger → class Exchanger < ExchangerImplementation
  • changed: class IVar < Synchronization::Object → class IVar < Synchronization::LockableObject
  • changed: class ImmediateExecutor → class ImmediateExecutor < AbstractExecutorService
  • changed: class MVar → class MVar < Synchronization::Object
  • changed: class Maybe → class Maybe < Synchronization::Object
  • changed: class MutexAtomicBoolean < Synchronization::Object → class MutexAtomicBoolean
  • changed: class MutexAtomicFixnum < Synchronization::Object → class MutexAtomicFixnum
  • changed: class MutexSemaphore < Synchronization::Object → class MutexSemaphore < Synchronization::LockableObject
  • changed: class RubySingleThreadExecutor < RubyExecutorService → class RubySingleThreadExecutor < RubyThreadPoolExecutor
  • changed: class SafeTaskExecutor < Synchronization::Object → class SafeTaskExecutor < Synchronization::LockableObject
  • changed: class SerializedExecution < Synchronization::Object → class SerializedExecution < Synchronization::LockableObject
  • changed: class TVar → class TVar < Synchronization::Object
  • changed: class ThreadLocalVar < ThreadLocalVarImplementation → class ThreadLocalVar
  • changed: constructor AbstractExecutorService(*) → constructor AbstractExecutorService(_ = …)
  • changed: method Promise.then(_ = …) → method Promise.then(*)
  • changed: method RubyThreadPoolExecutor.ready_worker(_) → method RubyThreadPoolExecutor.ready_worker(_, _)
  • added: class AbstractExchanger < Synchronization::Object
  • added: class Agent < Synchronization::LockableObject
  • added: class Array < ArrayImplementation
  • added: class AtomicMarkableReference < ::Concurrent::Synchronization::Object
  • added: class CRubySet < ::Set
  • added: class FiberLocalVar
  • added: class Hash < HashImplementation
  • added: class JRubyArray < ::Array
  • added: class JRubyHash < ::Hash
  • added: class JRubySet < ::Set
  • added: class JavaExchanger < AbstractExchanger
  • added: class LockFreeStack < Synchronization::Object
  • added: class LockLocalVar
  • added: class Map < Collection::MapImplementation
  • added: class MultipleErrors < Error
  • added: class MutexCountDownLatch < Synchronization::LockableObject
  • added: class NULL < ::Object.new
  • added: class RubyExchanger < AbstractExchanger
  • added: class Set < SetImplementation
  • added: class SynchronizedDelegator < SimpleDelegator
  • added: class TruffleRubyArray < ::Array
  • added: class TruffleRubyAtomicReference < TruffleRuby::AtomicReference
  • added: class TruffleRubyHash < ::Hash
  • added: class TruffleRubySet < ::Set
  • added: class Tuple
  • added: const Collection.MapImplementation
  • added: const JavaThreadPoolExecutor.DEFAULT_SYNCHRONOUS
  • added: const LockFreeStack.EMPTY
  • added: const RubyThreadPoolExecutor.DEFAULT_SYNCHRONOUS
  • added: const TimerTask.DEFAULT_INTERVAL_TYPE
  • added: const TimerTask.FIXED_DELAY
  • added: const TimerTask.FIXED_RATE
  • added: constructor AbstractExchanger()
  • added: constructor Agent(_, _ = …)
  • added: constructor AtomicMarkableReference(_ = …, _ = …)
  • added: constructor FiberLocalVar(_ = …)
  • added: constructor JavaExchanger()
  • added: constructor LockFreeStack(_ = …)
  • added: constructor Map(_ = …)
  • added: constructor MultipleAssignmentError(_ = …, _ = …)
  • added: constructor MultipleErrors(_, _ = …)
  • added: constructor MutexCountDownLatch(_ = …)
  • added: constructor RubyExchanger()
  • added: constructor SynchronizedDelegator(_)
  • added: constructor ThreadLocalVar(_ = …)
  • added: constructor Tuple(_)
  • added: method AbstractExchanger.exchange!(_, _ = …)
  • added: method AbstractExchanger.exchange(_, _ = …)
  • added: method AbstractExchanger.try_exchange(_, _ = …)
  • added: method AbstractExecutorService.to_s()
  • added: method Agent.<<(_)
  • added: method Agent.await()
  • added: method Agent.await_for!(_)
  • added: method Agent.await_for(_)
  • added: method Agent.deref()
  • added: method Agent.error()
  • added: method Agent.failed?()
  • added: method Agent.post(*)
  • added: method Agent.reason()
  • added: method Agent.restart(_, _ = …)
  • added: method Agent.send!(*)
  • added: method Agent.send(*)
  • added: method Agent.send_off!(*)
  • added: method Agent.send_off(*)
  • added: method Agent.send_via!(_, *)
  • added: method Agent.send_via(_, *)
  • added: method Agent.stopped?()
  • added: method Agent.value()
  • added: method Agent.wait(_ = …)
  • added: method Async.call()
  • added: method Async.cast()
  • added: method Async.init_synchronization()
  • added: method Atom.reset(_)
  • added: method AtomicBoolean.inspect()
  • added: method AtomicBoolean.to_s()
  • added: method AtomicFixnum.inspect()
  • added: method AtomicFixnum.to_s()
  • added: method AtomicMarkableReference.compare_and_set(_, _, _, _)
  • added: method AtomicMarkableReference.compare_and_swap(_, _, _, _)
  • added: method AtomicMarkableReference.get()
  • added: method AtomicMarkableReference.mark()
  • added: method AtomicMarkableReference.marked?()
  • added: method AtomicMarkableReference.set(_, _)
  • added: method AtomicMarkableReference.try_update!()
  • added: method AtomicMarkableReference.try_update()
  • added: method AtomicMarkableReference.update()
  • added: method AtomicMarkableReference.value()
  • added: method AtomicReference.inspect()
  • added: method AtomicReference.to_s()
  • added: method FiberLocalVar.bind(_)
  • added: method FiberLocalVar.value()
  • added: method JavaThreadPoolExecutor.active_count()
  • added: method JavaThreadPoolExecutor.prune_pool()
  • added: method LockFreeStack.clear()
  • added: method LockFreeStack.clear_each()
  • added: method LockFreeStack.clear_if(_)
  • added: method LockFreeStack.compare_and_clear(_)
  • added: method LockFreeStack.compare_and_pop(_)
  • added: method LockFreeStack.compare_and_push(_, _)
  • added: method LockFreeStack.each(_ = …)
  • added: method LockFreeStack.empty?(_ = …)
  • added: method LockFreeStack.inspect()
  • added: method LockFreeStack.peek()
  • added: method LockFreeStack.pop()
  • added: method LockFreeStack.push(_)
  • added: method LockFreeStack.replace_if(_, _)
  • added: method LockFreeStack.to_s()
  • added: method MVar.borrow(_ = …)
  • added: method Map.[](_)
  • added: method Map.each_key()
  • added: method Map.each_pair()
  • added: method Map.each_value()
  • added: method Map.empty?()
  • added: method Map.fetch(_, _ = …)
  • added: method Map.fetch_or_store(_, _ = …)
  • added: method Map.inspect()
  • added: method Map.key(_)
  • added: method Map.keys()
  • added: method Map.marshal_dump()
  • added: method Map.marshal_load(_)
  • added: method Map.put_if_absent(_, _)
  • added: method Map.size()
  • added: method Map.value?(_)
  • added: method Map.values()
  • added: method MultipleAssignmentError.inspect()
  • added: method MutexCountDownLatch.count()
  • added: method MutexCountDownLatch.count_down()
  • added: method MutexCountDownLatch.wait(_ = …)
  • added: method ReInclude.include(*)
  • added: method RubyThreadPoolExecutor.active_count()
  • added: method RubyThreadPoolExecutor.completed_task_count()
  • added: method RubyThreadPoolExecutor.largest_length()
  • added: method RubyThreadPoolExecutor.prune_pool()
  • added: method RubyThreadPoolExecutor.prune_worker(_)
  • added: method RubyThreadPoolExecutor.remove_worker(_)
  • added: method RubyThreadPoolExecutor.scheduled_task_count()
  • added: method RubyThreadPoolExecutor.worker_task_completed()
  • added: method SynchronizedDelegator.setup()
  • added: method SynchronizedDelegator.teardown()
  • added: method ThreadLocalVar.bind(_)
  • added: method ThreadLocalVar.value()
  • added: method Transaction.open(_)
  • added: method TruffleRubyAtomicReference.compare_and_swap()
  • added: method TruffleRubyAtomicReference.swap()
  • added: method TruffleRubyAtomicReference.value()
  • added: method TruffleRubyAtomicReference.value=()
  • added: method Tuple.cas(_, _, _)
  • added: method Tuple.compare_and_set(_, _, _)
  • added: method Tuple.each()
  • added: method Tuple.get(_)
  • added: method Tuple.set(_, _)
  • added: method Tuple.volatile_get(_)
  • added: method Tuple.volatile_set(_, _)
  • added: module Options
  • added: module Promises
  • added: module ReInclude
  • added: module ThreadSafe
  • added: property AbstractExecutorService.name: reader
  • added: property Agent.error_mode: reader
  • added: property JavaThreadPoolExecutor.synchronous: reader
  • added: property MultipleAssignmentError.inspection_data: reader
  • added: property MultipleErrors.errors: reader
  • added: property RubyThreadPoolExecutor.synchronous: reader
  • added: property TimerTask.interval_type: reader
  • added: property Tuple.size: reader
  • added: protected method FiberLocalVar.default()
  • added: protected method MVar.synchronize()
  • added: protected method MutexAtomicBoolean.synchronize()
  • added: protected method MutexAtomicFixnum.synchronize()
  • added: protected method MutexAtomicReference.synchronize()
  • added: protected method MutexCountDownLatch.ns_initialize(_)
  • added: protected method ThreadLocalVar.default()
  • added: set FiberLocalVar.value(_)
  • added: set ThreadLocalVar.value(_)
  • added: static method Agent.await(*)
  • added: static method Agent.await_for!(_, *)
  • added: static method Agent.await_for(_, *)
  • added: static method LockFreeStack.next_node()
  • added: static method LockFreeStack.of1(_)
  • added: static method LockFreeStack.of2(_, _)
  • added: static method Options.executor(_)
  • added: static method Options.executor_from_options(_ = …)
  • added: static method Synchronization.full_memory_barrier()
  • added: class Error < StandardError
  • added: class ValidationError < Error
  • added: constructor Error(_ = …)
  • added: constructor ValidationError(_ = …)
  • removed: class JavaPriorityQueue
  • removed: class MutexPriorityQueue
  • removed: class PriorityQueue < PriorityQueueImplementation
  • removed: constructor JavaPriorityQueue(_ = …)
  • removed: constructor MutexPriorityQueue(_ = …)
  • removed: method JavaPriorityQueue.clear()
  • removed: method JavaPriorityQueue.delete(_)
  • removed: method JavaPriorityQueue.deq()
  • removed: method JavaPriorityQueue.empty?()
  • removed: method JavaPriorityQueue.enq(_)
  • removed: method JavaPriorityQueue.has_priority?(_)
  • removed: method JavaPriorityQueue.include?(_)
  • removed: method JavaPriorityQueue.length()
  • removed: method JavaPriorityQueue.peek()
  • removed: method JavaPriorityQueue.pop()
  • removed: method JavaPriorityQueue.push(_)
  • removed: method JavaPriorityQueue.shift()
  • removed: method JavaPriorityQueue.size()
  • removed: method MutexPriorityQueue.clear()
  • removed: method MutexPriorityQueue.delete(_)
  • removed: method MutexPriorityQueue.deq()
  • removed: method MutexPriorityQueue.empty?()
  • removed: method MutexPriorityQueue.enq(_)
  • removed: method MutexPriorityQueue.has_priority?(_)
  • removed: method MutexPriorityQueue.include?(_)
  • removed: method MutexPriorityQueue.length()
  • removed: method MutexPriorityQueue.peek()
  • removed: method MutexPriorityQueue.pop()
  • removed: method MutexPriorityQueue.push(_)
  • removed: method MutexPriorityQueue.shift()
  • removed: method MutexPriorityQueue.size()
  • removed: method PriorityQueue.deq()
  • removed: method PriorityQueue.enq()
  • removed: method PriorityQueue.has_priority?()
  • removed: method PriorityQueue.shift()
  • removed: method PriorityQueue.size()
  • removed: protected method MutexPriorityQueue.ordered?(_, _)
  • removed: protected method MutexPriorityQueue.sink(_)
  • removed: protected method MutexPriorityQueue.swap(_, _)
  • removed: protected method MutexPriorityQueue.swim(_)
  • removed: static method JavaPriorityQueue.from_list(_, _ = …)
  • removed: static method MutexPriorityQueue.from_list(_, _ = …)
  • changed: class CopyOnNotifyObserverSet < Synchronization::Object → class CopyOnNotifyObserverSet < Synchronization::LockableObject
  • changed: class CopyOnWriteObserverSet < Synchronization::Object → class CopyOnWriteObserverSet < Synchronization::LockableObject
  • added: class JavaNonConcurrentPriorityQueue
  • added: class MriMapBackend < NonConcurrentMapBackend
  • added: class NonConcurrentMapBackend
  • added: class NonConcurrentPriorityQueue < NonConcurrentPriorityQueueImplementation
  • added: class RubyNonConcurrentPriorityQueue
  • added: class SynchronizedMapBackend < NonConcurrentMapBackend
  • added: class TimeoutQueue < TimeoutQueueImplementation
  • added: class TruffleRubyMapBackend < TruffleRuby::ConcurrentMap
  • added: constructor JavaNonConcurrentPriorityQueue(_ = …)
  • added: constructor MriMapBackend(_ = …)
  • added: constructor NonConcurrentMapBackend(_ = …)
  • added: constructor RubyNonConcurrentPriorityQueue(_ = …)
  • added: constructor SynchronizedMapBackend(*)
  • added: constructor TruffleRubyMapBackend(_ = …)
  • added: method JavaNonConcurrentPriorityQueue.clear()
  • added: method JavaNonConcurrentPriorityQueue.delete(_)
  • added: method JavaNonConcurrentPriorityQueue.deq()
  • added: method JavaNonConcurrentPriorityQueue.empty?()
  • added: method JavaNonConcurrentPriorityQueue.enq(_)
  • added: method JavaNonConcurrentPriorityQueue.has_priority?(_)
  • added: method JavaNonConcurrentPriorityQueue.include?(_)
  • added: method JavaNonConcurrentPriorityQueue.length()
  • added: method JavaNonConcurrentPriorityQueue.peek()
  • added: method JavaNonConcurrentPriorityQueue.pop()
  • added: method JavaNonConcurrentPriorityQueue.push(_)
  • added: method JavaNonConcurrentPriorityQueue.shift()
  • added: method JavaNonConcurrentPriorityQueue.size()
  • added: method MriMapBackend.[]=(_, _)
  • added: method MriMapBackend.clear()
  • added: method MriMapBackend.compute(_)
  • added: method MriMapBackend.compute_if_absent(_)
  • added: method MriMapBackend.compute_if_present(_)
  • added: method MriMapBackend.delete(_)
  • added: method MriMapBackend.delete_pair(_, _)
  • added: method MriMapBackend.get_and_set(_, _)
  • added: method MriMapBackend.merge_pair(_, _)
  • added: method MriMapBackend.replace_if_exists(_, _)
  • added: method MriMapBackend.replace_pair(_, _, _)
  • added: method NonConcurrentMapBackend.[](_)
  • added: method NonConcurrentMapBackend.[]=(_, _)
  • added: method NonConcurrentMapBackend.clear()
  • added: method NonConcurrentMapBackend.compute(_)
  • added: method NonConcurrentMapBackend.compute_if_absent(_)
  • added: method NonConcurrentMapBackend.compute_if_present(_)
  • added: method NonConcurrentMapBackend.delete(_)
  • added: method NonConcurrentMapBackend.delete_pair(_, _)
  • added: method NonConcurrentMapBackend.each_pair()
  • added: method NonConcurrentMapBackend.get_and_set(_, _)
  • added: method NonConcurrentMapBackend.get_or_default(_, _)
  • added: method NonConcurrentMapBackend.key?(_)
  • added: method NonConcurrentMapBackend.merge_pair(_, _)
  • added: method NonConcurrentMapBackend.replace_if_exists(_, _)
  • added: method NonConcurrentMapBackend.replace_pair(_, _, _)
  • added: method NonConcurrentMapBackend.size()
  • added: method NonConcurrentPriorityQueue.deq()
  • added: method NonConcurrentPriorityQueue.enq()
  • added: method NonConcurrentPriorityQueue.has_priority?()
  • added: method NonConcurrentPriorityQueue.shift()
  • added: method NonConcurrentPriorityQueue.size()
  • added: method RubyNonConcurrentPriorityQueue.clear()
  • added: method RubyNonConcurrentPriorityQueue.delete(_)
  • added: method RubyNonConcurrentPriorityQueue.deq()
  • added: method RubyNonConcurrentPriorityQueue.empty?()
  • added: method RubyNonConcurrentPriorityQueue.enq(_)
  • added: method RubyNonConcurrentPriorityQueue.has_priority?(_)
  • added: method RubyNonConcurrentPriorityQueue.include?(_)
  • added: method RubyNonConcurrentPriorityQueue.length()
  • added: method RubyNonConcurrentPriorityQueue.peek()
  • added: method RubyNonConcurrentPriorityQueue.pop()
  • added: method RubyNonConcurrentPriorityQueue.push(_)
  • added: method RubyNonConcurrentPriorityQueue.shift()
  • added: method RubyNonConcurrentPriorityQueue.size()
  • added: method SynchronizedMapBackend.[](_)
  • added: method SynchronizedMapBackend.[]=(_, _)
  • added: method SynchronizedMapBackend.clear()
  • added: method SynchronizedMapBackend.compute(_)
  • added: method SynchronizedMapBackend.compute_if_absent(_)
  • added: method SynchronizedMapBackend.compute_if_present(_)
  • added: method SynchronizedMapBackend.delete(_)
  • added: method SynchronizedMapBackend.delete_pair(_, _)
  • added: method SynchronizedMapBackend.get_and_set(_, _)
  • added: method SynchronizedMapBackend.get_or_default(_, _)
  • added: method SynchronizedMapBackend.key?(_)
  • added: method SynchronizedMapBackend.merge_pair(_, _)
  • added: method SynchronizedMapBackend.replace_if_exists(_, _)
  • added: method SynchronizedMapBackend.replace_pair(_, _, _)
  • added: method SynchronizedMapBackend.size()
  • added: static method JavaNonConcurrentPriorityQueue.from_list(_, _ = …)
  • added: static method RubyNonConcurrentPriorityQueue.from_list(_, _ = …)
  • removed: method Obligation.completed?()
  • removed: protected method Dereferenceable.init_mutex(_ = …)
  • removed: protected method Dereferenceable.mutex()
  • changed: method Observable.add_observer(*) → method Observable.add_observer(_ = …, _ = …)
  • changed: method Observable.delete_observer(*) → method Observable.delete_observer(_)
  • changed: method Observable.with_observer(*) → method Observable.with_observer(_ = …, _ = …)
  • changed: protected method Obligation.init_obligation(*) → protected method Obligation.init_obligation()
  • added: const Logging.SEV_LABEL
  • removed: class Result
  • removed: constructor Result(_)
  • removed: method Result.can_wait?()
  • removed: method Result.timed_out?()
  • removed: method Result.woken_up?()
  • removed: property Result.remaining_time: reader
  • removed: class EMPTY < Object.new
  • added: class LOCALS < FiberLocals.new
  • removed: class NO_VALUE < Object.new
  • added: class Node
  • added: constructor Node(_, _)
  • added: property Node.next_node: reader
  • added: property Node.value: reader
  • added: property Node.value: writer
  • changed: class EMPTY < Object.new → class EMPTY < ::Object.new
  • changed: class TIMEOUT < Object.new → class TIMEOUT < ::Object.new
  • changed: class NONE < Object.new → class NONE < ::Object.new
  • added: class AbstractEventFuture < Synchronization::Object
  • added: class Event < AbstractEventFuture
  • added: class Future < AbstractEventFuture
  • added: class ResolvableEvent < Event
  • added: class ResolvableFuture < Future
  • added: const Future.SET_BACKTRACE_LOCATIONS_SUPPORTED
  • added: constructor AbstractEventFuture(_, _)
  • added: method AbstractEventFuture.add_callback_clear_delayed_node(_)
  • added: method AbstractEventFuture.add_callback_notify_blocked(_, _)
  • added: method AbstractEventFuture.blocks()
  • added: method AbstractEventFuture.callbacks()
  • added: method AbstractEventFuture.chain(*)
  • added: method AbstractEventFuture.chain_on(_, *)
  • added: method AbstractEventFuture.chain_resolvable(_)
  • added: method AbstractEventFuture.default_executor()
  • added: method AbstractEventFuture.inspect()
  • added: method AbstractEventFuture.on_resolution!(*)
  • added: method AbstractEventFuture.on_resolution(*)
  • added: method AbstractEventFuture.on_resolution_using(_, *)
  • added: method AbstractEventFuture.pending?()
  • added: method AbstractEventFuture.promise()
  • added: method AbstractEventFuture.resolve_with(_, _ = …, _ = …)
  • added: method AbstractEventFuture.resolved?()
  • added: method AbstractEventFuture.state()
  • added: method AbstractEventFuture.tangle(_)
  • added: method AbstractEventFuture.to_s()
  • added: method AbstractEventFuture.touch()
  • added: method AbstractEventFuture.touched?()
  • added: method AbstractEventFuture.wait(_ = …)
  • added: method AbstractEventFuture.waiting_threads()
  • added: method AbstractEventFuture.with_default_executor(_)
  • added: method AbstractEventFuture.with_hidden_resolvable()
  • added: method Event.any(_)
  • added: method Event.delay()
  • added: method Event.schedule(_)
  • added: method Event.then()
  • added: method Event.to_event()
  • added: method Event.to_future()
  • added: method Event.with_default_executor(_)
  • added: method Event.zip(_)
  • added: method FactoryMethods.any(*)
  • added: method FactoryMethods.any_event(*)
  • added: method FactoryMethods.any_event_on(_, *)
  • added: method FactoryMethods.any_fulfilled_future(*)
  • added: method FactoryMethods.any_fulfilled_future_on(_, *)
  • added: method FactoryMethods.any_resolved_future(*)
  • added: method FactoryMethods.any_resolved_future_on(_, *)
  • added: method FactoryMethods.delay(*)
  • added: method FactoryMethods.delay_on(_, *)
  • added: method FactoryMethods.fulfilled_future(_, _ = …)
  • added: method FactoryMethods.future(*)
  • added: method FactoryMethods.future_on(_, *)
  • added: method FactoryMethods.make_future(_ = …, _ = …)
  • added: method FactoryMethods.rejected_future(_, _ = …)
  • added: method FactoryMethods.resolvable_event()
  • added: method FactoryMethods.resolvable_event_on(_ = …)
  • added: method FactoryMethods.resolvable_future()
  • added: method FactoryMethods.resolvable_future_on(_ = …)
  • added: method FactoryMethods.resolved_event(_ = …)
  • added: method FactoryMethods.resolved_future(_, _, _, _ = …)
  • added: method FactoryMethods.schedule(_, *)
  • added: method FactoryMethods.schedule_on(_, _, *)
  • added: method FactoryMethods.zip(*)
  • added: method FactoryMethods.zip_events(*)
  • added: method FactoryMethods.zip_events_on(_, *)
  • added: method FactoryMethods.zip_futures(*)
  • added: method FactoryMethods.zip_futures_on(_, *)
  • added: method Future.any(_)
  • added: method Future.apply(_, _)
  • added: method Future.delay()
  • added: method Future.exception(*)
  • added: method Future.flat(_ = …)
  • added: method Future.flat_event()
  • added: method Future.flat_future(_ = …)
  • added: method Future.fulfilled?()
  • added: method Future.inspect()
  • added: method Future.on_fulfillment!(*)
  • added: method Future.on_fulfillment(*)
  • added: method Future.on_fulfillment_using(_, *)
  • added: method Future.on_rejection!(*)
  • added: method Future.on_rejection(*)
  • added: method Future.on_rejection_using(_, *)
  • added: method Future.reason(_ = …, _ = …)
  • added: method Future.rejected?()
  • added: method Future.rescue(*)
  • added: method Future.rescue_on(_, *)
  • added: method Future.result(_ = …)
  • added: method Future.run(_ = …)
  • added: method Future.schedule(_)
  • added: method Future.then(*)
  • added: method Future.then_on(_, *)
  • added: method Future.to_event()
  • added: method Future.to_future()
  • added: method Future.to_s()
  • added: method Future.value!(_ = …, _ = …)
  • added: method Future.value(_ = …, _ = …)
  • added: method Future.wait!(_ = …)
  • added: method Future.with_default_executor(_)
  • added: method Future.zip(_)
  • added: method ResolvableEvent.resolve(_ = …, _ = …)
  • added: method ResolvableEvent.wait(_ = …, _ = …)
  • added: method ResolvableEvent.with_hidden_resolvable()
  • added: method ResolvableFuture.evaluate_to!(*)
  • added: method ResolvableFuture.evaluate_to(*)
  • added: method ResolvableFuture.fulfill(_, _ = …, _ = …)
  • added: method ResolvableFuture.reason(_ = …, _ = …, _ = …)
  • added: method ResolvableFuture.reject(_, _ = …, _ = …)
  • added: method ResolvableFuture.resolve(_ = …, _ = …, _ = …, _ = …, _ = …)
  • added: method ResolvableFuture.result(_ = …, _ = …)
  • added: method ResolvableFuture.value!(_ = …, _ = …, _ = …)
  • added: method ResolvableFuture.value(_ = …, _ = …, _ = …)
  • added: method ResolvableFuture.wait!(_ = …, _ = …)
  • added: method ResolvableFuture.wait(_ = …, _ = …)
  • added: method ResolvableFuture.with_hidden_resolvable()
  • added: module FactoryMethods
  • added: module Resolvable
  • added: method Configuration.default_executor()
  • added: module Configuration
  • removed: class JavaObject < AbstractObject
  • removed: class MonitorObject < MutexObject
  • removed: class MutexObject < AbstractObject
  • removed: class RbxObject < AbstractObject
  • removed: constructor MonitorObject()
  • removed: constructor MutexObject()
  • removed: constructor RbxObject()
  • removed: method Object.new_condition()
  • removed: protected method AbstractObject.ensure_ivar_visibility!()
  • removed: protected method AbstractObject.ns_broadcast()
  • removed: protected method AbstractObject.ns_initialize(*)
  • removed: protected method AbstractObject.ns_signal()
  • removed: protected method AbstractObject.ns_wait(_ = …)
  • removed: protected method AbstractObject.ns_wait_until(_ = …)
  • removed: protected method AbstractObject.synchronize()
  • removed: protected method MonitorObject.ns_wait(_ = …)
  • removed: protected method MonitorObject.synchronize()
  • removed: protected method MutexObject.ensure_ivar_visibility!()
  • removed: protected method MutexObject.ns_broadcast()
  • removed: protected method MutexObject.ns_signal()
  • removed: protected method MutexObject.ns_wait(_ = …)
  • removed: protected method MutexObject.synchronize()
  • removed: protected method RbxObject.ensure_ivar_visibility!()
  • removed: protected method RbxObject.ns_broadcast()
  • removed: protected method RbxObject.ns_signal()
  • removed: protected method RbxObject.ns_wait(_ = …)
  • removed: protected method RbxObject.synchronize()
  • removed: protected static method RbxObject.attr_volatile(*)
  • removed: static method JavaObject.attr_volatile(*)
  • changed: class Condition < Object → class Condition < LockableObject
  • changed: class Lock < Object → class Lock < LockableObject
  • changed: class Object < Implementation → class Object < AbstractObject
  • changed: constructor AbstractObject(*) → constructor AbstractObject()
  • changed: protected static method AbstractObject.attr_volatile(*) → static method AbstractObject.attr_volatile(*)
  • added: class AbstractLockableObject < Synchronization::Object
  • added: class JRubyLockableObject < AbstractLockableObject
  • added: class LockableObject < LockableObjectImplementation
  • added: class MonitorLockableObject < AbstractLockableObject
  • added: class MutexLockableObject < AbstractLockableObject
  • added: constructor MonitorLockableObject()
  • added: constructor MutexLockableObject()
  • added: constructor Object()
  • added: method AbstractObject.full_memory_barrier()
  • added: method LockableObject.new_condition()
  • added: method SafeInitialization.new(*)
  • added: method Volatile.full_memory_barrier()
  • added: module ConditionSignalling
  • added: module SafeInitialization
  • added: module Volatile
  • added: protected method AbstractLockableObject.ns_broadcast()
  • added: protected method AbstractLockableObject.ns_signal()
  • added: protected method AbstractLockableObject.ns_wait(_ = …)
  • added: protected method AbstractLockableObject.ns_wait_until(_ = …)
  • added: protected method AbstractLockableObject.synchronize()
  • added: protected method AbstractStruct.ns_initialize_copy()
  • added: protected method ConditionSignalling.ns_broadcast()
  • added: protected method ConditionSignalling.ns_signal()
  • added: protected method MonitorLockableObject.ns_wait(_ = …)
  • added: protected method MonitorLockableObject.synchronize()
  • added: protected method MutexLockableObject.ns_wait(_ = …)
  • added: protected method MutexLockableObject.synchronize()
  • added: static method Object.atomic_attribute?(_)
  • added: static method Object.atomic_attributes(_ = …)
  • added: static method Object.attr_atomic(*)
  • added: static method Object.ensure_safe_initialization_when_final_fields_are_present()
  • added: static method Object.safe_initialization!()
  • added: static method Object.safe_initialization?()
  • added: method ClassMethods.attr_volatile(*)
  • added: module ClassMethods
  • added: class LOCALS < ThreadLocals.new
  • added: const Util.CPU_COUNT
  • added: const Util.FIXNUM_BIT_SIZE
  • added: const Util.MAX_INT
  • added: module Util
  • added: static method Util.make_synchronized_on_cruby(_)
  • added: static method Util.make_synchronized_on_truffleruby(_)
  • added: class Adder < Striped64
  • added: class PowerOfTwoTuple < Concurrent::Tuple
  • added: class Striped64
  • added: const Striped64.THREAD_LOCAL_KEY
  • added: const XorShiftRandom.MAX_XOR_SHIFTABLE_INT
  • added: constructor PowerOfTwoTuple(_)
  • added: constructor Striped64()
  • added: method Adder.add(_)
  • added: method Adder.decrement()
  • added: method Adder.increment()
  • added: method Adder.reset()
  • added: method Adder.sum()
  • added: method PowerOfTwoTuple.hash_to_index(_)
  • added: method PowerOfTwoTuple.next_in_size_table()
  • added: method PowerOfTwoTuple.volatile_get_by_hash(_)
  • added: method PowerOfTwoTuple.volatile_set_by_hash(_, _)
  • added: method Striped64.busy?()
  • added: method Striped64.retry_update(_, _, _)
  • added: method Volatile.attr_volatile(*)
  • added: method XorShiftRandom.get()
  • added: method XorShiftRandom.xorshift(_)
  • added: module Volatile
  • added: module XorShiftRandom
  • added: class Cell < Concurrent::AtomicReference
  • added: method Cell.cas()
  • added: method Cell.cas_computed()
  • added: static method Cell.padding()
  • removed: class ReadLogEntry < Struct.new(:tvar, :version)
  • changed: class ABORTED < Object.new → class ABORTED < ::Object.new
  • added: class OpenEntry < Struct.new(:value, :modified)
  • removed: method EngineDetector.on_jruby_9000?()
  • removed: method EngineDetector.on_rbx?()
  • removed: method EngineDetector.ruby_engine()
  • changed: method EngineDetector.ruby_version(_, _, _ = …, _ = …) → method EngineDetector.ruby_version(_ = …, _, _, _, _)
  • added: const NativeInteger.MAX_VALUE
  • added: const NativeInteger.MIN_VALUE
  • added: method EngineDetector.on_linux?()
  • added: method EngineDetector.on_osx?()
  • added: method EngineDetector.on_truffleruby?()
  • added: method NativeExtensionLoader.c_extensions_loaded?()
  • added: method NativeExtensionLoader.load_native_extensions()
  • added: method NativeInteger.ensure_integer(_)
  • added: method NativeInteger.ensure_integer_and_bounds(_)
  • added: method NativeInteger.ensure_lower_bound(_)
  • added: method NativeInteger.ensure_positive(_)
  • added: method NativeInteger.ensure_positive_and_no_zero(_)
  • added: method NativeInteger.ensure_upper_bound(_)
  • added: method ProcessorCounter.available_processor_count()
  • added: method ProcessorCounter.cpu_quota()
  • added: method ProcessorCounter.cpu_shares()
  • added: module NativeInteger