All Classes

Class	Description
AbstractPriorityScheduler	Abstract implementation for implementations of PrioritySchedulerService.
AbstractService	An abstract implementation of the Service interface.
AbstractSubmitterExecutor	Since the conversion to a SubmitterExecutor from an executor is often the same (just using the ListenableFutureTask to wrap the task).
AbstractSubmitterScheduler	Similar to the AbstractSubmitterExecutor this abstract class is designed to reduce code duplication for the multiple schedule functions.
ArrayIterator<T>	Implementation of Iterator which will go over an Object array.
AsyncCallListenerHelper<T>	This class changes the behavior of how listeners are called from the parent class ListenerHelper.
AsyncCallRunnableListenerHelper	This class changes the behavior of how listeners are called from the parent class RunnableListenerHelper.
BlockingQueueConsumer<T>	This class is designed for handling the threading and consumption of a high throughput BlockingQueue.
CallableContainer<T>	Interface to implement if any classes are containing a callable.
CancelDebuggingListenableFuture<T>	Wrapper for a ListenableFuture to provide enhanced features for debugging the state at which at which it was canceled.
CancelDebuggingListenableFuture.FutureProcessingStack	Throwable that is not thrown, but instead added as a cause to indicate the processing stack trace at the time of cancellation.
CentralThreadlyPool	Threadly's centrally provided pool manager.
Clock	This is a utility class for low-resolution timing which avoids frequent System.currentTimeMillis() calls (which perform poorly because they require system calls).
CompletableFutureAdapter	This class helps in converting between threadly's ListenableFuture and java's provided CompletableFuture.
ConcurrentArrayList<T>	A thread safe list implementation with an array back end.
ConfigurableThreadFactory	Implementation of ThreadFactory which is configurable for the most common use cases.
ConfigurableThreadFactory.ConfigurableThreadFactoryBuilder	Builder for configuring a new ConfigurableThreadFactory.
ConstantTimeWatchdog	This class is to guarantee that a given ListenableFuture is completed within a timeout.
ContainerHelper	Typically used only internally by the threadly library.
ControlledThreadProfiler	This class functions very similar to the Profiler.
DebugLogger	Often times when trying to understand a concurrency issue, adding logging may solve that problem.
DefaultExecutorListenerHelper<T>	This class ensures that listener execution will never happen on the thread that invokes ListenerHelper.call().
DefaultExecutorRunnableListenerHelper	This class ensures that listener execution will never happen on the thread that invokes RunnableListenerHelper.callListeners().
DefaultPriorityWrapper	Class to wrap any implementation of PrioritySchedulerService.
DoNothingRunnable	Runnable implementation which does no action.
ExceptionHandler	Interface for implementation to handle exceptions which occur.
ExceptionUtils	Utilities for doing basic operations with exceptions.
ExceptionUtils.TransformedException	Exception which is constructed from ExceptionUtils.makeRuntime(Throwable) when the exception was not a runtime exception.
ExceptionUtils.TransformedSuppressedStackException	Exception which is constructed from ExceptionUtils.makeRuntime(Throwable, boolean) when the exception was not a runtime exception, and stack is being suppressed.
ExecuteOnGetFutureTask<T>	This future task has a special ability to start execution in the thread requesting the ExecuteOnGetFutureTask.get() IF it has not already started.
ExecutorLimiter	This class is designed to limit how much parallel execution happens on a provided Executor.
ExecutorQueueLimitRejector	A simple way to limit any Executor so that queues are managed.
ExecutorStatisticWrapper	Wrap an Executor to get statistics based off executions through this wrapper.
ExecutorTaskInterceptor	Class to wrap Executor pool so that tasks can be intercepted and either wrapped, or modified, before being submitted to the pool.
FilteredStackProfiler	This class functions very similar to the Profiler.
FlowControlledNoFailureProcessor<T>	Implementation of FlowControlledProcessor which assumes all exceptions are unexpected.
FlowControlledNoResultProcessor	Implementation of FlowControlledProcessor which reduces boiler plate code when no result is expected.
FlowControlledProcessor<T>	Abstract implementation which will do async processing, but only submit a limited number of tasks processing concurrently.
FutureCallback<T>	Callback for accepting the results of a future once the future has completed.
FutureUtils	A collection of small utilities for handling futures.
ImmediateFailureListenableFuture<T>	Completed implementation of ListenableFuture that will immediately provide a failure condition.
ImmediateResultListenableFuture<T>	Completed implementation of ListenableFuture that will immediately return a result.
InvocationTee	Simple utility for multiplying invocations across multiple instances of a given interface.
KeyDistributedExecutor	TaskDistributor is designed such that tasks executed on it for a given key will run in a single threaded manner.
KeyDistributedScheduler	This is a class which is more full featured than KeyDistributedExecutor, but it does require a scheduler implementation in order to be able to perform scheduling.
KeyedExecutorLimiter	This is a cross between the KeyDistributedExecutor and an ExecutorLimiter.
KeyedRateLimiterExecutor	Similar to RateLimiterExecutor except that the rate is applied on a per key basis.
KeyedSchedulerServiceLimiter	This is a cross between the KeyDistributedScheduler and a SchedulerServiceLimiter.
KeyedSubmitterSchedulerLimiter	This is a cross between the KeyDistributedScheduler and a SubmitterSchedulerLimiter.
ListenableFuture<T>	Future where you can add a listener which is called once the future has completed.
ListenableFuture.ListenerOptimizationStrategy	Strategy to use for optimizing listener execution.
ListenableFutureAdapterTask<T>	Adapter from java's Future to threadly's ListenableFuture.
ListenableFutureTask<T>	This is a future which can be executed.
ListenableRunnableFuture<T>	This is a ListenableFuture which can be executed.
ListenableScheduledFuture<T>	Interface which includes the ScheduledFuture interface as well as the ListenableFuture interface.
ListenerHelper<T>	Class which assist with holding and calling to listeners of any interface.
MixedTimeWatchdog	A class which handles a collection of ConstantTimeWatchdog instances.
MutablePair<L,R>	A special type of Pair which allows the stored references to be updated after creation.
NoThreadScheduler	Executor which has no threads itself.
NoThreadSchedulerStatisticTracker	An implementation of NoThreadScheduler which tracks run and usage statistics.
OrderedExecutorLimiter<T extends java.lang.Runnable>	Implementation of ExecutorLimiter which allows you to order the tasks in a way other than FIFO.
Pair<L,R>	A simple tuple implementation (every library needs one, right?).
Poller	Simple class for watching a condition and getting notified when a state has changed.
PollingWatchdog	This class is designed to help ensure a future completes with an arbitrary condition to determine when a future should be canceled.
PriorityDelegatingScheduler	Wrapper which will delegate the tasks provided to a specific scheduler designated for their priority.
PriorityScheduler	Executor to run tasks, schedule tasks.
PrioritySchedulerService	This interface represents schedulers which can not only execute and schedule tasks, but run based off a given priority as well.
PrioritySchedulerServiceQueueLimitRejector	A simple way to limit any PrioritySchedulerService so that queues are managed.
PrioritySchedulerServiceWrapper	This is a wrapper for PriorityScheduler to be a drop in replacement for any ScheduledExecutorService (AKA the ScheduledThreadPoolExecutor interface).
PrioritySchedulerStatisticTracker	An implementation of PriorityScheduler which tracks run and usage statistics.
PrioritySchedulerTaskInterceptor	Class to wrap PrioritySchedulerService pool so that tasks can be intercepted and either wrapped, or modified, before being submitted to the pool.
Profiler	Tool for profiling a running java application to get an idea of where the slow points (either because of lock contention, or because of high computational demand).
RateLimiterExecutor	Another way to limit executions on a scheduler.
RejectedExecutionHandler	Interface to be invoked when a limiter can not accept a task for any reason.
ReschedulingOperation	Abstract implementation for more complicated recurring behavior.
RunnableCallableAdapter<T>	Converts a Runnable with a result into a Callable.
RunnableChain	A class to chain multiple runnables to later be run together, within the same thread.
RunnableContainer	Interface to implement if any classes are containing a runnable.
RunnableListenerHelper	Class which assist with holding and calling to Runnable listeners.
SameThreadSubmitterExecutor	A SubmitterExecutor that will run all provided tasks immediately in the same thread that is invoking into it with the task.
ScheduledExecutorServiceWrapper	This is a wrapper for the ScheduledThreadPoolExecutor to use that implementation with the SubmitterScheduler.
SchedulerExecutorDelegator	Class which takes in both an executor and a scheduler.
SchedulerService	This interface adds some more advanced features to a scheduler that are more service oriented.
SchedulerServiceLimiter	This class is designed to limit how much parallel execution happens on a provided SchedulerService.
SchedulerServiceQueueLimitRejector	A simple way to limit any SchedulerService so that queues are managed.
SchedulerServiceTaskInterceptor	Class to wrap SchedulerService pool so that tasks can be intercepted and either wrapped, or modified, before being submitted to the pool.
SchedulingUtils	Class for helping calculate the offset for scheduling tasks.
Service	A service is defined as something which is constructed in a stopped state (unless the constructor starts the service automatically).
SettableListenableFuture<T>	This class is designed to be a helper when returning a single result asynchronously.
SingleThreadScheduler	A simple and light weight implementation of the SchedulerService.
SingleThreadSchedulerServiceWrapper	This is a wrapper for SingleThreadScheduler to be a drop in replacement for any ScheduledExecutorService (AKA the ScheduledThreadPoolExecutor interface).
SingleThreadSchedulerStatisticTracker	An implementation of SingleThreadScheduler which tracks run and usage statistics.
SingleThreadSchedulerSubPool	This sub-pool is a special type of limiter.
SortUtils	A collection of utilities for searching and sorting against collections and other data providers.
StackSuppressedRuntimeException	Type of RuntimeException which does not generate a stack at it's point of creation.
StackTracker	This thread safe class allows you to record stacks in the code so that you can understand HOW something is being called.
StatisticExecutor	Interface for some basic statistic elements provided by any statistic executor/scheduler or any executor/scheduler wrappers.
StatisticPriorityScheduler	An extension of StatisticExecutor, defining specific behavior when the statistic tracker is implementing for a scheduler which has a concept of task priorities.
StatisticsUtils	Utilities for getting some basic statistics out of numerical data collections.
StringBufferWriter	Class to wrap a StringBuffer to implement the Writer interface.
StringBuilderWriter	Class to wrap a StringBuilder to implement the Writer interface.
StringUtils	Some small utilities and constants around handling strings.
SubmitterExecutor	A thread pool for executing tasks with provided futures.
SubmitterExecutorAdapter	A simple wrapper class for Executor implementations to provide SubmitterExecutor capabilities.
SubmitterScheduler	A thread pool for scheduling tasks with provided futures.
SubmitterSchedulerLimiter	This class is designed to limit how much parallel execution happens on a provided SubmitterScheduler.
SubmitterSchedulerQueueLimitRejector	A simple way to limit any SubmitterScheduler so that queues are managed.
SubmitterSchedulerTaskInterceptor	Class to wrap SubmitterScheduler pool so that tasks can be intercepted and either wrapped, or modified, before being submitted to the pool.
TaskPriority	Priority to go with tasks when being submitted into implementations of PrioritySchedulerService.
ThreadReferencingThreadFactory	A thread factory which keeps a WeakReference to each thread.
ThreadReferencingThreadFactory.ThreadReferencingThreadFactoryBuilder	Builder for configuring a new ThreadReferencingThreadFactory.
ThreadRenamingExecutor	Class which wraps a Executor and wraps all supplied tasks in a ThreadRenamingRunnable.
ThreadRenamingPriorityScheduler	Class which wraps a PrioritySchedulerService and wraps all supplied tasks in a ThreadRenamingRunnable.
ThreadRenamingRunnable	A simple runnable wrapper which will rename the thread during execution, and set the name back at the end of execution.
ThreadRenamingSchedulerService	Class which wraps a SchedulerService and wraps all supplied tasks in a ThreadRenamingRunnable.
ThreadRenamingSubmitterScheduler	Class which wraps a SubmitterScheduler and wraps all supplied tasks in a ThreadRenamingRunnable.
ThrowableSuppressingRunnable	Class that is designed to wrap a runnable, and prevent any throwables from propagating out of the run function.
UnfairExecutor	A very high performance SubmitterExecutor implementation.
UnfairExecutor.AtomicStripeGenerator	Stripe generator which will round robin distribute tasks to threads.
UnfairExecutor.TaskHashXorTimeStripeGenerator	Generator which will determine the task stripe by using the identity hash of the runnable and Clock.lastKnownTimeNanos().
UnfairExecutor.TaskStripeGenerator	Strategy for taking in a task and producing a long which will be translated to which thread the task should be distributed on to.