jdantonio/concurrent-ruby
Modern concurrency tools including agents, futures, promises, thread pools, supervisors, and more. Inspired by Erlang, Clojure, Scala, Go, Java, JavaScript, and classic concurrency patterns. – Read the documentation
This page shows an evaluation of the documentation of jdantonio/concurrent-ruby.
Each class, module, method, etc. is given a grade based on how complete the docs are.
The bar above shows the distribution of these grades.
| Seems really good | ||
|---|---|---|
|
A
|
Concurrent |
|
|
A
|
Concurrent::Actress.spawn_optionify |
|
|
A
|
Concurrent::MVar#try_take! |
|
|
A
|
Concurrent::MVar#modify! |
|
|
A
|
Concurrent::Logging#log |
|
| Show 252 more ... | ||
|
A
|
Concurrent:: … #notify_and_delete_observers |
|
|
A
|
Concurrent:: … #notify_and_delete_observers |
|
|
A
|
Concurrent::CopyOnNotifyObserverSet#notify_observers |
|
|
A
|
Concurrent::CopyOnWriteObserverSet#notify_observers |
|
|
A
|
Concurrent::RubyThreadPoolExecutor#length |
|
|
A
|
Concurrent::JavaThreadPoolExecutor#length |
|
|
A
|
Concurrent::MutexAtomicFixnum#decrement |
|
|
A
|
Concurrent::MutexAtomicFixnum#increment |
|
|
A
|
Concurrent::JavaAtomicFixnum#decrement |
|
|
A
|
Concurrent::JavaAtomicFixnum#increment |
|
|
A
|
Concurrent::MutexPriorityQueue#length |
|
|
A
|
Concurrent::JavaPriorityQueue#length |
|
|
A
|
Concurrent::Actress::Reference#tell |
|
|
A
|
Concurrent::Actress::Reference#ask! |
|
|
A
|
Concurrent::MutexPriorityQueue#pop |
|
|
A
|
Concurrent::Dereferenceable#value |
|
|
A
|
Concurrent::JavaPriorityQueue#pop |
|
|
A
|
Concurrent::Obligation#no_error! |
|
|
A
|
Concurrent::Agent#validate |
|
|
A
|
Concurrent::Agent#rescue |
|
|
A
|
Concurrent::Observable#with_observer |
|
|
A
|
Concurrent::MutexPriorityQueue#push |
|
|
A
|
Concurrent::JavaPriorityQueue#push |
|
|
A
|
Concurrent::CopyOnNotifyObserverSet#add_observer |
|
|
A
|
Concurrent::CopyOnWriteObserverSet#add_observer |
|
|
A
|
Concurrent::RubyThreadPoolExecutor |
|
|
A
|
Concurrent::RubyExecutor#post |
|
|
A
|
Concurrent::OneByOne#post |
|
|
A
|
Concurrent::Async#async |
|
|
A
|
Concurrent::Async#await |
|
|
A
|
Concurrent::Actor.pool |
|
|
A
|
Concurrent.dataflow |
|
|
A
|
Concurrent.timer |
|
|
A
|
Concurrent::JavaThreadPoolExecutor#completed_task_count |
|
|
A
|
Concurrent::JavaThreadPoolExecutor#scheduled_task_count |
|
|
A
|
Concurrent::RubyThreadPoolExecutor#remaining_capacity |
|
|
A
|
Concurrent::JavaThreadPoolExecutor#remaining_capacity |
|
|
A
|
Concurrent::CopyOnNotifyObserverSet#delete_observers |
|
|
A
|
Concurrent::CopyOnWriteObserverSet#delete_observers |
|
|
A
|
Concurrent::CopyOnNotifyObserverSet#count_observers |
|
|
A
|
Concurrent::CopyOnWriteObserverSet#count_observers |
|
|
A
|
Concurrent::JavaThreadPoolExecutor#largest_length |
|
|
A
|
Concurrent::Configuration#global_operation_pool |
|
|
A
|
Concurrent::RubyThreadPoolExecutor#queue_length |
|
|
A
|
Concurrent::JavaThreadPoolExecutor#queue_length |
|
|
A
|
Concurrent::CopyOnNotifyObserverSet#initialize |
|
|
A
|
Concurrent::JavaThreadPoolExecutor#min_length |
|
|
A
|
Concurrent::CopyOnWriteObserverSet#initialize |
|
|
A
|
Concurrent::MutexAtomicFixnum#compare_and_set |
|
|
A
|
Concurrent::JavaThreadPoolExecutor#max_length |
|
|
A
|
Concurrent::JavaAtomicFixnum#compare_and_set |
|
|
A
|
Concurrent::JavaThreadPoolExecutor#idletime |
|
|
A
|
Concurrent::Configuration#global_task_pool |
|
|
A
|
Concurrent::MutexAtomicBoolean#initialize |
|
|
A
|
Concurrent::MutexAtomicBoolean#make_false |
|
|
A
|
Concurrent::TimerTask#execution_interval= |
|
|
A
|
Concurrent::JavaAtomicBoolean#make_false |
|
|
A
|
Concurrent::CyclicBarrier#number_waiting |
|
|
A
|
Concurrent::UnbufferedChannel#initialize |
|
|
A
|
Concurrent::MutexAtomicBoolean#make_true |
|
|
A
|
Concurrent::TimerTask#execution_interval |
|
|
A
|
Concurrent::JavaAtomicBoolean#make_true |
|
|
A
|
Concurrent::BlockingRingBuffer#capacity |
|
|
A
|
Concurrent::ProcessorCounter#initialize |
|
|
A
|
Concurrent::TimerTask#timeout_interval= |
|
|
A
|
Concurrent::Observable#delete_observers |
|
|
A
|
Concurrent::JavaPriorityQueue.from_list |
|
|
A
|
Concurrent::TimerTask#timeout_interval |
|
|
A
|
Concurrent::Observable#count_observers |
|
|
A
|
Concurrent::MutexAtomicBoolean#value= |
|
|
A
|
Concurrent::MutexPriorityQueue#delete |
|
|
A
|
Concurrent::MutexCountDownLatch#count |
|
|
A
|
Concurrent::JavaAtomicBoolean#value= |
|
|
A
|
Concurrent::MutexCountDownLatch#wait |
|
|
A
|
Concurrent::CyclicBarrier#initialize |
|
|
A
|
Concurrent::JavaPriorityQueue#delete |
|
|
A
|
Concurrent::JavaCountDownLatch#count |
|
|
A
|
Concurrent::Configuration#initialize |
|
|
A
|
Concurrent::MutexAtomicBoolean#value |
|
|
A
|
Concurrent::BlockingRingBuffer#count |
|
|
A
|
Concurrent::Actress::CoreDelegations |
|
|
A
|
Concurrent::JavaCountDownLatch#wait |
|
|
A
|
Concurrent::MutexAtomicFixnum#value |
|
|
A
|
Concurrent::CopyOnNotifyObserverSet |
|
|
A
|
Concurrent::BlockingRingBuffer#peek |
|
|
A
|
Concurrent::WaitableList#initialize |
|
|
A
|
Concurrent::JavaAtomicBoolean#value |
|
|
A
|
Concurrent::BlockingRingBuffer#take |
|
|
A
|
Concurrent::MutexPriorityQueue#peek |
|
|
A
|
Concurrent::JavaPriorityQueue#peek |
|
|
A
|
Concurrent::CopyOnWriteObserverSet |
|
|
A
|
Concurrent::Transaction#initialize |
|
|
A
|
Concurrent::Actress::Reference#ask |
|
|
A
|
Concurrent::JavaAtomicFixnum#value |
|
|
A
|
Concurrent::CyclicBarrier#parties |
|
|
A
|
Concurrent::TimerTask#initialize |
|
|
A
|
Concurrent::Condition#initialize |
|
|
A
|
Concurrent::OneByOne#initialize |
|
|
A
|
Concurrent::Async.validate_argc |
|
|
A
|
Concurrent::Condition#broadcast |
|
|
A
|
Concurrent::MutexCountDownLatch |
|
|
A
|
Concurrent::CyclicBarrier#reset |
|
|
A
|
Concurrent::RingBuffer#capacity |
|
|
A
|
Concurrent::Actress::TypeCheck |
|
|
A
|
Concurrent::Actress::Reference |
|
|
A
|
Concurrent::JavaCountDownLatch |
|
|
A
|
Concurrent::Promise#initialize |
|
|
A
|
Concurrent::CyclicBarrier#wait |
|
|
A
|
Concurrent::Delay#reconfigure |
|
|
A
|
Concurrent::TimerTask.execute |
|
|
A
|
Concurrent::JavaExecutor#post |
|
|
A
|
Concurrent::SafeTaskExecutor |
|
|
A
|
Concurrent::RingBuffer#count |
|
|
A
|
Concurrent::Actress::Context |
|
|
A
|
Concurrent::Event#initialize |
|
|
A
|
Concurrent::Condition#signal |
|
|
A
|
Concurrent::Delay#initialize |
|
|
A
|
Concurrent::RingBuffer#poll |
|
|
A
|
Concurrent::RingBuffer#peek |
|
|
A
|
Concurrent::Actress.current |
|
|
A
|
Concurrent::Obligation#wait |
|
|
A
|
Concurrent::JavaExecutor#<< |
|
|
A
|
Concurrent::Dereferenceable |
|
|
A
|
Concurrent::RubyExecutor#<< |
|
|
A
|
Concurrent::Agent#post_off |
|
|
A
|
Concurrent::Future.execute |
|
|
A
|
Concurrent::Future#execute |
|
|
A
|
Concurrent::Actress::Root |
|
|
A
|
Concurrent::OptionsParser |
|
|
A
|
Concurrent::Configuration |
|
|
A
|
Concurrent::Agent#timeout |
|
|
A
|
Concurrent::Postable#post |
|
|
A
|
Concurrent::Event#reset |
|
|
A
|
Concurrent::Agent#await |
|
|
A
|
Concurrent::RingBuffer |
|
|
A
|
Concurrent::Agent#post |
|
|
A
|
Concurrent.atomically |
|
|
A
|
Concurrent::Actor#act |
|
|
A
|
Concurrent::TimerTask |
|
|
A
|
Concurrent::Condition |
|
|
A
|
Concurrent::Event#set |
|
|
A
|
Concurrent::OneByOne |
|
|
A
|
Concurrent::TimerSet |
|
|
A
|
Concurrent::Actress |
|
|
A
|
Concurrent::Logging |
|
|
A
|
Concurrent::Agent |
|
|
A
|
Concurrent::IVar |
|
|
A
|
Concurrent::MVar |
|
|
A
|
Concurrent::TVar |
|
|
A
|
Concurrent::RubyThreadPoolExecutor#completed_task_count |
|
|
A
|
Concurrent::RubyThreadPoolExecutor#scheduled_task_count |
|
|
A
|
Concurrent::RubyThreadPoolExecutor#overflow_policy |
|
|
A
|
Concurrent::RubyThreadPoolExecutor#largest_length |
|
|
A
|
Concurrent::RubyThreadPoolExecutor#max_length |
|
|
A
|
Concurrent::RubyThreadPoolExecutor#min_length |
|
|
A
|
Concurrent::RubyThreadPoolExecutor#max_queue |
|
|
A
|
Concurrent::RubyThreadPoolExecutor#idletime |
|
|
A
|
Concurrent::MutexCountDownLatch#count_down |
|
|
A
|
Concurrent::RubyThreadPoolExecutor#status |
|
|
A
|
Concurrent::JavaCountDownLatch#count_down |
|
|
A
|
Concurrent::JavaThreadPoolExecutor#status |
|
|
A
|
Concurrent::MutexPriorityQueue#clear |
|
|
A
|
Concurrent::JavaPriorityQueue#clear |
|
|
A
|
Concurrent::Configuration#no_logger |
|
|
A
|
Concurrent::Configuration#logger= |
|
|
A
|
Concurrent::JavaExecutor#shutdown |
|
|
A
|
Concurrent::RubyExecutor#shutdown |
|
|
A
|
Concurrent::Configuration#logger |
|
|
A
|
Concurrent::RubyExecutor#kill |
|
|
A
|
Concurrent::JavaExecutor#kill |
|
|
A
|
Concurrent.abort_transaction |
|
|
A
|
Concurrent::MVar#modify |
|
|
A
|
Concurrent::TVar#value= |
|
|
A
|
Concurrent::TVar#value |
|
|
A
|
Concurrent::Event#wait |
|
|
A
|
Concurrent::MVar#take |
|
|
A
|
Concurrent::MVar#put |
|
|
A
|
Concurrent::CopyOnNotifyObserverSet#delete_observer |
|
|
A
|
Concurrent::CopyOnWriteObserverSet#delete_observer |
|
|
A
|
Concurrent::BlockingRingBuffer#put |
|
|
A
|
Concurrent::Exchanger#exchange |
|
|
A
|
Concurrent::RingBuffer#offer |
|
|
A
|
Concurrent::ProcessorCounter#physical_processor_count |
|
|
A
|
Concurrent::OptionsParser#get_operation_executor_from |
|
|
A
|
Concurrent::OptionsParser#get_task_executor_from |
|
|
A
|
Concurrent::Configuration#global_operation_pool= |
|
|
A
|
Concurrent::JavaSingleThreadExecutor#initialize |
|
|
A
|
Concurrent::RubySingleThreadExecutor#initialize |
|
|
A
|
Concurrent::RubyExecutor#wait_for_termination |
|
|
A
|
Concurrent::JavaExecutor#wait_for_termination |
|
|
A
|
Concurrent::RubyThreadPoolExecutor#initialize |
|
|
A
|
Concurrent::ProcessorCounter#processor_count |
|
|
A
|
Concurrent::TimerSet.calculate_schedule_time |
|
|
A
|
Concurrent::Configuration#global_task_pool= |
|
|
A
|
Concurrent::OptionsParser#get_executor_from |
|
|
A
|
Concurrent::Configuration#global_timer_set |
|
|
A
|
Concurrent::MutexCountDownLatch#initialize |
|
|
A
|
Concurrent::JavaCountDownLatch#initialize |
|
|
A
|
Concurrent::MutexPriorityQueue#initialize |
|
|
A
|
Concurrent::MutexAtomicFixnum#initialize |
|
|
A
|
Concurrent::JavaPriorityQueue#initialize |
|
|
A
|
Concurrent::Actress::Context#on_message |
|
|
A
|
Concurrent::ScheduledTask#initialize |
|
|
A
|
Concurrent::RubySingleThreadExecutor |
|
|
A
|
Concurrent::MutexAtomicFixnum#value= |
|
|
A
|
Concurrent::JavaSingleThreadExecutor |
|
|
A
|
Concurrent::JavaAtomicFixnum#value= |
|
|
A
|
Concurrent::Dereferenceable#mutex |
|
|
A
|
Concurrent::RubyCachedThreadPool |
|
|
A
|
Concurrent::JavaCachedThreadPool |
|
|
A
|
Concurrent::TimerSet#initialize |
|
|
A
|
Concurrent::RubyFixedThreadPool |
|
|
A
|
Concurrent::MutexPriorityQueue |
|
|
A
|
Concurrent::MutexAtomicBoolean |
|
|
A
|
Concurrent::MutexAtomicFixnum |
|
|
A
|
Concurrent::JavaAtomicBoolean |
|
|
A
|
Concurrent::JavaPriorityQueue |
|
|
A
|
Concurrent::Agent#initialize |
|
|
A
|
Concurrent::JavaAtomicFixnum |
|
|
A
|
Concurrent::Async#init_mutex |
|
|
A
|
Concurrent::Async#executor= |
|
|
A
|
Concurrent::IVar#initialize |
|
|
A
|
Concurrent::MVar#initialize |
|
|
A
|
Concurrent::TimerSet#post |
|
|
A
|
Concurrent::IVar#fail |
|
|
A
|
Concurrent::Agent#<< |
|
|
A
|
Concurrent::IVar#set |
|
|
A
|
Concurrent.configure |
|
|
A
|
Concurrent::Future |
|
|
A
|
Concurrent.timeout |
|
|
A
|
Concurrent::Actor |
|
|
A
|
Concurrent::Async |
|
|
A
|
Concurrent::Delay |
|
|
A
|
Concurrent::Event |
|
|
A
|
Concurrent::Dereferenceable#value= |
|
|
A
|
Concurrent::Dereferenceable#set_deref_options |
|
|
A
|
Concurrent::Condition::Result#woken_up? |
|
|
A
|
Concurrent::MutexPriorityQueue#include? |
|
|
A
|
Concurrent::Dereferenceable#init_mutex |
|
|
A
|
Concurrent::JavaPriorityQueue#include? |
|
|
A
|
Concurrent::Actress::AdHoc#on_message |
|
|
A
|
Concurrent::Channel::Probe#initialize |
|
|
A
|
Concurrent::Actress::Root#on_message |
|
|
A
|
Concurrent::Obligation#fulfilled? |
|
|
A
|
Concurrent::Channel::Probe#value |
|
|
A
|
Concurrent::TimerTask#execute |
|
|
A
|
Concurrent::Future#initialize |
|
|
A
|
Concurrent::Obligation#value |
|
|
A
|
Concurrent::JavaThreadPoolExecutor#shutdown |
|
|
A
|
Concurrent::Actress::Core#terminate! |
|
|
A
|
Concurrent::Actress::Core#guard! |
|
|
A
|
Concurrent::TimerSet#kill |
|
| Proper documentation present | ||
|---|---|---|
|
B
|
Concurrent::Actress::Context::ClassMethods#spawn! |
|
|
B
|
Concurrent::Actress.spawn! |
|
|
B
|
Concurrent::MVar#try_put! |
|
|
B
|
Concurrent::MVar#set! |
|
|
B
|
Concurrent::Obligation#value! |
|
| Show 6 more ... | ||
|
B
|
Concurrent::Actress::Context::ClassMethods#spawn |
|
|
B
|
Concurrent::ScheduledTask#add_observer |
|
|
B
|
Concurrent::Actress::Reference#message |
|
|
B
|
Concurrent::TVar#initialize |
|
|
B
|
Concurrent::Condition#wait |
|
|
B
|
Concurrent::IVar#add_observer |
|
| Needs work | ||
|---|---|---|
|
C
|
Concurrent::TimerTask.run! |
|
|
C
|
Concurrent::TimerTask#run! |
|
|
C
|
Concurrent::Promise#rescue |
|
|
C
|
Concurrent::Observable#add_observer |
|
|
C
|
Concurrent::Actress::Context#terminate! |
|
| Show 16 more ... | ||
|
C
|
Concurrent::Actress.spawn |
|
|
C
|
Concurrent::Observable#delete_observer |
|
|
C
|
Concurrent::Promise#then |
|
|
C
|
Concurrent::Actress::Context#spawn |
|
|
C
|
Concurrent::SafeTaskExecutor#execute |
|
|
C
|
Concurrent::Obligation#exception |
|
|
C
|
Concurrent::Promise#on_success |
|
|
C
|
Concurrent::TimerTask#terminate |
|
|
C
|
Concurrent::Postable#forward |
|
|
C
|
Concurrent::TimerTask#cancel |
|
|
C
|
Concurrent::TimerTask#stop |
|
|
C
|
Concurrent::Promise#execute |
|
|
C
|
Concurrent::Promise.fulfill |
|
|
C
|
Concurrent::Promise.reject |
|
|
C
|
Concurrent::Actress::Context#children |
|
|
C
|
Concurrent::TimerTask#run |
|
| Undocumented | ||
|---|---|---|
|
U
|
Concurrent::Actress::TypeCheck#Match! |
|
|
U
|
Concurrent::Actress::TypeCheck#Child! |
|
|
U
|
Concurrent::Actress::TypeCheck#Type! |
|
|
U
|
Concurrent::Postable#post! |
|
|
U
|
Concurrent::Supervisor#run! |
|
| Show 206 more ... | ||
|
U
|
Concurrent::Runnable#run! |
|
|
U
|
Concurrent::Actress::CoreDelegations#reference |
|
|
U
|
Concurrent::Promise#synchronized_set_state! |
|
|
U
|
Concurrent::Supervisor#restart_strategy |
|
|
U
|
Concurrent::Actress::AdHoc#initialize |
|
|
U
|
Concurrent::Supervisor#restart_worker |
|
|
U
|
Concurrent::Supervisor#remove_worker |
|
|
U
|
Concurrent::Supervisor#start_worker |
|
|
U
|
Concurrent::Actress::Reference#to_s |
|
|
U
|
Concurrent::PerThreadExecutor#post |
|
|
U
|
Concurrent::Supervisor#add_workers |
|
|
U
|
Concurrent::Supervisor#stop_worker |
|
|
U
|
Concurrent::ImmediateExecutor#post |
|
|
U
|
Concurrent::Supervisor#max_restart |
|
|
U
|
Concurrent::Supervisor#add_worker |
|
|
U
|
Concurrent::ScheduledTask#cancel |
|
|
U
|
Concurrent::Supervisor#max_time |
|
|
U
|
Concurrent::Promise#set_state! |
|
|
U
|
Concurrent::Supervisor#length |
|
|
U
|
Concurrent.dataflow_with |
|
|
U
|
Concurrent::JavaThreadPoolExecutor |
|
|
U
|
Concurrent::PerThreadExecutor.post |
|
|
U
|
Concurrent::Stoppable#before_stop |
|
|
U
|
Concurrent::ScheduledTask.execute |
|
|
U
|
Concurrent::RubyExecutor#execute |
|
|
U
|
Concurrent::Promise.execute |
|
|
U
|
Concurrent::Channel.select |
|
|
U
|
Concurrent::Supervisor |
|
|
U
|
Concurrent::JavaThreadPoolExecutor#overflow_policy |
|
|
U
|
Concurrent::Supervisor::WorkerCounts#supervisors= |
|
|
U
|
Concurrent::Actress::ActressTerminated#initialize |
|
|
U
|
Concurrent::Supervisor::WorkerCounts#supervisors |
|
|
U
|
Concurrent::Actress::CoreDelegations#terminated |
|
|
U
|
Concurrent::Transaction::ReadLogEntry#version= |
|
|
U
|
Concurrent::Supervisor::WorkerContext#restart= |
|
|
U
|
Concurrent::Channel::Probe#set_unless_assigned |
|
|
U
|
Concurrent::Actress::CoreDelegations#executor |
|
|
U
|
Concurrent::Supervisor::WorkerContext#worker= |
|
|
U
|
Concurrent::Supervisor::WorkerCounts#workers= |
|
|
U
|
Concurrent::Supervisor::WorkerContext#restart |
|
|
U
|
Concurrent::Transaction::ReadLogEntry#version |
|
|
U
|
Concurrent::BufferedChannel#buffer_queue_size |
|
|
U
|
Concurrent::JavaThreadPoolExecutor#initialize |
|
|
U
|
Concurrent::CyclicBarrier::Generation#status= |
|
|
U
|
Concurrent::Supervisor#current_restart_count |
|
|
U
|
Concurrent::Supervisor::WorkerContext#worker |
|
|
U
|
Concurrent::Condition::Result#remaining_time |
|
|
U
|
Concurrent::Transaction::UndoLogEntry#value= |
|
|
U
|
Concurrent::CyclicBarrier::Generation#status |
|
|
U
|
Concurrent::JavaThreadPoolExecutor#max_queue |
|
|
U
|
Concurrent::Supervisor::WorkerCounts#workers |
|
|
U
|
Concurrent::UnbufferedChannel#probe_set_size |
|
|
U
|
Concurrent::Configuration#new_operation_pool |
|
|
U
|
Concurrent::Transaction::UndoLogEntry#tvar= |
|
|
U
|
Concurrent::Actress::CoreDelegations#parent |
|
|
U
|
Concurrent::Transaction::UndoLogEntry#value |
|
|
U
|
Concurrent::Supervisor::WorkerCounts#specs= |
|
|
U
|
Concurrent::Supervisor::WorkerContext#type= |
|
|
U
|
Concurrent::Transaction::ReadLogEntry#tvar= |
|
|
U
|
Concurrent::Supervisor::WorkerCounts#specs |
|
|
U
|
Concurrent::UnbufferedChannel#remove_probe |
|
|
U
|
Concurrent::Supervisor::WorkerContext#type |
|
|
U
|
Concurrent::BufferedChannel#probe_set_size |
|
|
U
|
Concurrent::Channel::Probe#composite_value |
|
|
U
|
Concurrent::Actress::Context::ClassMethods |
|
|
U
|
Concurrent::Transaction::UndoLogEntry#tvar |
|
|
U
|
Concurrent::Transaction::ReadLogEntry#tvar |
|
|
U
|
Concurrent::Actress::CoreDelegations#name |
|
|
U
|
Concurrent::Actress::CoreDelegations#path |
|
|
U
|
Concurrent::BlockingRingBuffer#initialize |
|
|
U
|
Concurrent::Condition::Result#initialize |
|
|
U
|
Concurrent::MutexPriorityQueue.from_list |
|
|
U
|
Concurrent::Runnable::Context#initialize |
|
|
U
|
Concurrent::BufferedChannel#remove_probe |
|
|
U
|
Concurrent::JavaAtomicBoolean#initialize |
|
|
U
|
Concurrent::RubyThreadPoolWorker#status |
|
|
U
|
Concurrent::MutexAtomic#compare_and_set |
|
|
U
|
Concurrent::Supervisor#monitor_interval |
|
|
U
|
Concurrent::Configuration#new_task_pool |
|
|
U
|
Concurrent::ScheduledTask#schedule_time |
|
|
U
|
Concurrent::JavaAtomicFixnum#initialize |
|
|
U
|
Concurrent::SafeTaskExecutor#initialize |
|
|
U
|
Concurrent::ThreadLocalSymbolAllocator |
|
|
U
|
Concurrent::Actress::Envelope#message= |
|
|
U
|
Concurrent::BufferedChannel#initialize |
|
|
U
|
Concurrent::Actress::ActressTerminated |
|
|
U
|
Concurrent::ThreadLocalVar#initialize |
|
|
U
|
Concurrent::Transaction::UndoLogEntry |
|
|
U
|
Concurrent::Transaction::ReadLogEntry |
|
|
U
|
Concurrent::Actress::Envelope#sender= |
|
|
U
|
Concurrent::Actress::Envelope#message |
|
|
U
|
Concurrent::Supervisor::WorkerContext |
|
|
U
|
Concurrent::Runnable::Context#thread |
|
|
U
|
Concurrent::Supervisor::WorkerCounts |
|
|
U
|
Concurrent::Runnable::Context#runner |
|
|
U
|
Concurrent::Actress::Envelope#sender |
|
|
U
|
Concurrent::Agent#operation_executor |
|
|
U
|
Concurrent::UnbufferedChannel#select |
|
|
U
|
Concurrent::Actress::Envelope#ivar= |
|
|
U
|
Concurrent::OneByOne::Job#executor= |
|
|
U
|
Concurrent::Actress::Context#logger |
|
|
U
|
Concurrent.physical_processor_count |
|
|
U
|
Concurrent::Channel::Probe#channel |
|
|
U
|
Concurrent::MutexAtomic#initialize |
|
|
U
|
Concurrent::Actress::Envelope#ivar |
|
|
U
|
Concurrent::UnbufferedChannel#push |
|
|
U
|
Concurrent::BufferedChannel#select |
|
|
U
|
Concurrent::OneByOne::Job#executor |
|
|
U
|
Concurrent::ThreadLocalJavaStorage |
|
|
U
|
Concurrent::ScheduledTask#execute |
|
|
U
|
Concurrent::UnbufferedChannel#pop |
|
|
U
|
Concurrent::RingBuffer#initialize |
|
|
U
|
Concurrent::Supervisor#initialize |
|
|
U
|
Concurrent::Actress::Reference#== |
|
|
U
|
Concurrent::Actress::Context#core |
|
|
U
|
Concurrent::ThreadLocalVar#value= |
|
|
U
|
Concurrent::ThreadLocalNewStorage |
|
|
U
|
Concurrent::ThreadLocalOldStorage |
|
|
U
|
Concurrent::ThreadLocalVar#value |
|
|
U
|
Concurrent::OneByOne::Job#block= |
|
|
U
|
Concurrent::Exchanger#initialize |
|
|
U
|
Concurrent::ImmediateExecutor#<< |
|
|
U
|
Concurrent::Transaction.current= |
|
|
U
|
Concurrent::BufferedChannel#push |
|
|
U
|
Concurrent::PerThreadExecutor#<< |
|
|
U
|
Concurrent::BufferedChannel#pop |
|
|
U
|
Concurrent::WaitableList#delete |
|
|
U
|
Concurrent::JavaFixedThreadPool |
|
|
U
|
Concurrent::OneByOne::Job#block |
|
|
U
|
Concurrent::Agent#task_executor |
|
|
U
|
Concurrent::OneByOne::Job#args= |
|
|
U
|
Concurrent::Transaction.current |
|
|
U
|
Concurrent::BlockingRingBuffer |
|
|
U
|
Concurrent::Transaction#unlock |
|
|
U
|
Concurrent::Transaction#commit |
|
|
U
|
Concurrent::OneByOne::Job#args |
|
|
U
|
Concurrent::MutexAtomic#value= |
|
|
U
|
Concurrent::MutexAtomic#modify |
|
|
U
|
Concurrent::Actress::Envelope |
|
|
U
|
Concurrent::Obligation#reason |
|
|
U
|
Concurrent::WaitableList#size |
|
|
U
|
Concurrent::WaitableList#take |
|
|
U
|
Concurrent::PerThreadExecutor |
|
|
U
|
Concurrent::MutexAtomic#value |
|
|
U
|
Concurrent::Transaction#write |
|
|
U
|
Concurrent::ImmediateExecutor |
|
|
U
|
Concurrent::UnbufferedChannel |
|
|
U
|
Concurrent::Condition::Result |
|
|
U
|
Concurrent::Transaction#abort |
|
|
U
|
Concurrent::Runnable::Context |
|
|
U
|
Concurrent::WaitableList#put |
|
|
U
|
Concurrent::Supervisor#count |
|
|
U
|
Concurrent::Obligation#state |
|
|
U
|
Concurrent::Transaction#read |
|
|
U
|
Concurrent::ProcessorCounter |
|
|
U
|
Concurrent::Supervisor#stop |
|
|
U
|
Concurrent::BufferedChannel |
|
|
U
|
Concurrent.processor_count |
|
|
U
|
Concurrent::Channel::Probe |
|
|
U
|
Concurrent::Supervisor#run |
|
|
U
|
Concurrent::Actress::AdHoc |
|
|
U
|
Concurrent::ThreadLocalVar |
|
|
U
|
Concurrent::CyclicBarrier |
|
|
U
|
Concurrent::OneByOne::Job |
|
|
U
|
Concurrent::Runnable#stop |
|
|
U
|
Concurrent::ScheduledTask |
|
|
U
|
Concurrent::WaitableList |
|
|
U
|
Concurrent::JavaExecutor |
|
|
U
|
Concurrent::RubyExecutor |
|
|
U
|
Concurrent::Runnable#run |
|
|
U
|
Concurrent::Transaction |
|
|
U
|
Concurrent::Postable#<< |
|
|
U
|
Concurrent::MutexAtomic |
|
|
U
|
Concurrent::Obligation |
|
|
U
|
Concurrent::Observable |
|
|
U
|
Concurrent::Exchanger |
|
|
U
|
Concurrent::Stoppable |
|
|
U
|
Concurrent::Postable |
|
|
U
|
Concurrent::Runnable |
|
|
U
|
Concurrent::Executor |
|
|
U
|
Concurrent::Channel |
|
|
U
|
Concurrent::Promise |
|
|
U
|
Concurrent::ThreadLocalSymbolAllocator#allocate_symbol |
|
|
U
|
Concurrent::ThreadLocalJavaStorage#allocate_storage |
|
|
U
|
Concurrent::ThreadLocalNewStorage#allocate_storage |
|
|
U
|
Concurrent::ThreadLocalOldStorage#allocate_storage |
|
|
U
|
Concurrent::RubyExecutor#shutdown_execution |
|
|
U
|
Concurrent::JavaExecutor#set_shutdown_hook |
|
|
U
|
Concurrent::RubyExecutor#kill_execution |
|
|
U
|
Concurrent::RubyExecutor#stopped_event |
|
|
U
|
Concurrent::Stoppable#before_stop_proc |
|
|
U
|
Concurrent::RubyExecutor#init_executor |
|
|
U
|
Concurrent::ThreadLocalJavaStorage#get |
|
|
U
|
Concurrent::ThreadLocalJavaStorage#set |
|
|
U
|
Concurrent::ThreadLocalOldStorage#set |
|
|
U
|
Concurrent::ThreadLocalOldStorage#get |
|
|
U
|
Concurrent::ThreadLocalNewStorage#get |
|
|
U
|
Concurrent::ThreadLocalNewStorage#set |
|
|
U
|
Concurrent::RubyExecutor#stop_event |
|
|
U
|
Concurrent::Observable#observers= |
|
|
U
|
Concurrent::Observable#observers |
|
|
U
|
Concurrent::Promise#notify_child |
|
|
U
|
Concurrent::Promise#set_pending |
|
|
U
|
Concurrent::RubyExecutor#mutex |
|
|
U
|
Concurrent::Runnable#mutex |
|
|
U
|
Concurrent::JavaFixedThreadPool#initialize |
|
Let's raise the visibility of documentation in Ruby!
This page is for jdantonio/concurrent-ruby and is part of a project called "Inch Pages", showing documentation measurements provided by Inch.
Inch Pages also provides a badge: 
(not counting low priority objects)
Can I have my own badges?
What is the goal of this?
I really think that posting badges for documentation in READMEs will benefit you (because people can see that your project is well documented) and our community in general by improving the visibility of documentation.
Let's start a discussion, let's raise the visibility of documentation, let's talk.
Suggestions, feedback, critique: Hit me up on Twitter or via issue.
nch Pages