SEPExecutor (apache-cassandra API)

java.lang.Object
- org.apache.cassandra.concurrent.SEPExecutor

All Implemented Interfaces:

java.util.concurrent.Executor, java.util.concurrent.ExecutorService, ExecutorPlus, LocalAwareExecutorPlus, ResizableThreadPool, SEPExecutorMBean
```
public class SEPExecutor
extends java.lang.Object
implements LocalAwareExecutorPlus, SEPExecutorMBean
```

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class SEPExecutor.TakeTaskPermitResult
- Nested classes/interfaces inherited from interface org.apache.cassandra.concurrent.ExecutorPlus
  ExecutorPlus.MaximumPoolSizeListener

Nested Classes
Modifier and Type	Class and Description
`static class`	`SEPExecutor.TakeTaskPermitResult`

Field Summary

Fields
Modifier and Type Field and Description

ThreadPoolMetrics metrics

java.lang.String name

protected java.util.concurrent.ConcurrentLinkedQueue<java.lang.Runnable> tasks

Fields
Modifier and Type	Field and Description
`ThreadPoolMetrics`	`metrics`
`java.lang.String`	`name`
`protected java.util.concurrent.ConcurrentLinkedQueue<java.lang.Runnable>`	`tasks`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected <T extends java.lang.Runnable> T`	`addTask(T task)`
`boolean`	`awaitTermination(long timeout, java.util.concurrent.TimeUnit unit)`
`void`	`execute(java.lang.Runnable run)`
`void`	`execute(WithResources withResources, java.lang.Runnable run)` Invoke `task`.
`int`	`getActiveTaskCount()` Returns the approximate number of threads that are actively executing tasks.
`long`	`getCompletedTaskCount()` Returns the approximate total number of tasks that have completed execution.
`int`	`getCorePoolSize()` Returns core pool size of thread pool, the minimum number of workers (where that makes sense for a thread pool, SEPExecutor does not have a minimum size).
`int`	`getMaximumPoolSize()` Returns maximum pool size of thread pool.
`int`	`getMaxTasksQueued()`
`int`	`getPendingTaskCount()` Returns the approximate total of tasks waiting to be executed.
`boolean`	`inExecutor()`
`boolean`	`isShutdown()`
`boolean`	`isTerminated()`
`void`	`maybeExecuteImmediately(java.lang.Runnable task)` MAY execute `task` immediately, if the calling thread is permitted to do so.
`protected void`	`onCompletion()`
`void`	`setCorePoolSize(int newCorePoolSize)` Allows user to resize minimum size of the thread pool.
`void`	`setMaximumPoolSize(int newMaximumPoolSize)` Allows user to resize maximum size of the thread pool.
`void`	`shutdown()`
`java.util.List<java.lang.Runnable>`	`shutdownNow()`
`<T> Future<T>`	`submit(java.util.concurrent.Callable<T> call)` Overrides `ExecutorService.submit(Callable)` to return a Cassandra `Future`
`Future<?>`	`submit(java.lang.Runnable run)` Overrides `ExecutorService.submit(Runnable)` to return a Cassandra `Future`
`<T> Future<T>`	`submit(java.lang.Runnable run, T result)` Overrides `ExecutorService.submit(Runnable, Object)` to return a Cassandra `Future`
`<T> Future<T>`	`submit(WithResources withResources, java.util.concurrent.Callable<T> call)` Invoke `task`, returning a future representing this computation.
`Future<?>`	`submit(WithResources withResources, java.lang.Runnable run)` Invoke `task`, returning a future yielding `null` if successful, or the abnormal termination of `task` otherwise.
`<T> Future<T>`	`submit(WithResources withResources, java.lang.Runnable run, T result)` Invoke `task`, returning a future yielding `result` if successful, or the abnormal termination of `task` otherwise.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.apache.cassandra.concurrent.ExecutorPlus
invokeAll, invokeAll, invokeAny, invokeAny

- Field Detail
  - name
```
public final java.lang.String name
```
  - metrics
```
public final ThreadPoolMetrics metrics
```
  - tasks
```
protected final java.util.concurrent.ConcurrentLinkedQueue<java.lang.Runnable> tasks
```
- Method Detail
  - onCompletion
```
protected void onCompletion()
```
  - getMaxTasksQueued
```
public int getMaxTasksQueued()
```
    Specified by:
    
    getMaxTasksQueued in interface ResizableThreadPool
  - addTask
```
protected <T extends java.lang.Runnable> T addTask(T task)
```
  - maybeExecuteImmediately
```
public void maybeExecuteImmediately(java.lang.Runnable task)
```
    Description copied from interface: ExecutorPlus
    
    MAY execute task immediately, if the calling thread is permitted to do so.
    
    Specified by:
    
    maybeExecuteImmediately in interface ExecutorPlus
  - execute
```
public void execute(java.lang.Runnable run)
```
    Specified by:
    
    execute in interface java.util.concurrent.Executor
  - execute
```
public void execute(WithResources withResources,
                    java.lang.Runnable run)
```
    Description copied from interface: ExecutorPlus
    
    Invoke task. The invoking thread will first instantiate the resources provided before invoking task, so that thread state may be modified and cleaned up. The invoking thread will execute something semantically equivlent to: try (Closeable close = withResources.get()) { task.run(); }
    
    Specified by:
    
    execute in interface ExecutorPlus
    
    Parameters:
    
    withResources - the resources to create and hold while executing task
    
    run - the task to execute
  - submit
```
public Future<?> submit(java.lang.Runnable run)
```
    Description copied from interface: ExecutorPlus
    
    Overrides ExecutorService.submit(Runnable) to return a Cassandra Future
    
    Specified by:
    
    submit in interface java.util.concurrent.ExecutorService
    
    Specified by:
    
    submit in interface ExecutorPlus
  - submit
```
public <T> Future<T> submit(java.lang.Runnable run,
                            T result)
```
    Description copied from interface: ExecutorPlus
    
    Overrides ExecutorService.submit(Runnable, Object) to return a Cassandra Future
    
    Specified by:
    
    submit in interface java.util.concurrent.ExecutorService
    
    Specified by:
    
    submit in interface ExecutorPlus
  - submit
```
public <T> Future<T> submit(java.util.concurrent.Callable<T> call)
```
    Description copied from interface: ExecutorPlus
    
    Overrides ExecutorService.submit(Callable) to return a Cassandra Future
    
    Specified by:
    
    submit in interface java.util.concurrent.ExecutorService
    
    Specified by:
    
    submit in interface ExecutorPlus
  - submit
```
public <T> Future<T> submit(WithResources withResources,
                            java.lang.Runnable run,
                            T result)
```
    Description copied from interface: ExecutorPlus
    
    Invoke task, returning a future yielding result if successful, or the abnormal termination of task otherwise. The invoking thread will first instantiate the resources provided before invoking task, so that thread state may be modified and cleaned up. The invoking thread will execute something semantically equivlent to: try (Closeable close = withResources.get()) { task.run(); return result; }
    
    Specified by:
    
    submit in interface ExecutorPlus
    
    Parameters:
    
    withResources - the resources to create and hold while executing task
    
    run - the task to execute
    
    result - the result if successful
  - submit
```
public Future<?> submit(WithResources withResources,
                        java.lang.Runnable run)
```
    Description copied from interface: ExecutorPlus
    
    Invoke task, returning a future yielding null if successful, or the abnormal termination of task otherwise. The invoking thread will first instantiate the resources provided before invoking task, so that thread state may be modified and cleaned up try (Closeable close = withResources.get()) { task.run(); return null; }
    
    Specified by:
    
    submit in interface ExecutorPlus
    
    Parameters:
    
    withResources - the resources to create and hold while executing task
    
    run - the task to execute
  - submit
```
public <T> Future<T> submit(WithResources withResources,
                            java.util.concurrent.Callable<T> call)
```
    Description copied from interface: ExecutorPlus
    
    Invoke task, returning a future representing this computation. The invoking thread will first instantiate the resources provided before invoking task, so that thread state may be modified and cleaned up. The invoking thread will execute something semantically equivlent to: try (Closeable close = withResources.get()) { return task.call(); }
    
    Specified by:
    
    submit in interface ExecutorPlus
    
    Parameters:
    
    withResources - the resources to create and hold while executing task
    
    call - the task to execute
  - inExecutor
```
public boolean inExecutor()
```
    Specified by:
    
    inExecutor in interface ExecutorPlus
    
    Returns:
    
    true iff the caller is a worker thread actively serving this executor
  - shutdown
```
public void shutdown()
```
    Specified by:
    
    shutdown in interface java.util.concurrent.ExecutorService
  - shutdownNow
```
public java.util.List<java.lang.Runnable> shutdownNow()
```
    Specified by:
    
    shutdownNow in interface java.util.concurrent.ExecutorService
  - isShutdown
```
public boolean isShutdown()
```
    Specified by:
    
    isShutdown in interface java.util.concurrent.ExecutorService
  - isTerminated
```
public boolean isTerminated()
```
    Specified by:
    
    isTerminated in interface java.util.concurrent.ExecutorService
  - awaitTermination
```
public boolean awaitTermination(long timeout,
                                java.util.concurrent.TimeUnit unit)
                         throws java.lang.InterruptedException
```
    Specified by:
    
    awaitTermination in interface java.util.concurrent.ExecutorService
    
    Throws:
    
    java.lang.InterruptedException
  - getPendingTaskCount
```
public int getPendingTaskCount()
```
    Description copied from interface: ResizableThreadPool
    
    Returns the approximate total of tasks waiting to be executed. Because the states of tasks and threads may change dynamically during computation, the returned value is only an approximation.
    
    Specified by:
    
    getPendingTaskCount in interface ResizableThreadPool
    
    Returns:
    
    the number of tasks
  - getCompletedTaskCount
```
public long getCompletedTaskCount()
```
    Description copied from interface: ResizableThreadPool
    
    Returns the approximate total number of tasks that have completed execution. Because the states of tasks and threads may change dynamically during computation, the returned value is only an approximation, but one that does not ever decrease across successive calls.
    
    Specified by:
    
    getCompletedTaskCount in interface ResizableThreadPool
    
    Returns:
    
    the number of tasks
  - getActiveTaskCount
```
public int getActiveTaskCount()
```
    Description copied from interface: ResizableThreadPool
    
    Returns the approximate number of threads that are actively executing tasks.
    
    Specified by:
    
    getActiveTaskCount in interface ResizableThreadPool
    
    Returns:
    
    the number of threads
  - getCorePoolSize
```
public int getCorePoolSize()
```
    Description copied from interface: ResizableThreadPool
    
    Returns core pool size of thread pool, the minimum number of workers (where that makes sense for a thread pool, SEPExecutor does not have a minimum size).
    
    Specified by:
    
    getCorePoolSize in interface ResizableThreadPool
  - setCorePoolSize
```
public void setCorePoolSize(int newCorePoolSize)
```
    Description copied from interface: ResizableThreadPool
    
    Allows user to resize minimum size of the thread pool.
    
    Specified by:
    
    setCorePoolSize in interface ResizableThreadPool
  - getMaximumPoolSize
```
public int getMaximumPoolSize()
```
    Description copied from interface: ResizableThreadPool
    
    Returns maximum pool size of thread pool.
    
    Specified by:
    
    getMaximumPoolSize in interface ResizableThreadPool
  - setMaximumPoolSize
```
public void setMaximumPoolSize(int newMaximumPoolSize)
```
    Description copied from interface: ResizableThreadPool
    
    Allows user to resize maximum size of the thread pool.
    
    Specified by:
    
    setMaximumPoolSize in interface ResizableThreadPool

Class SEPExecutor

Nested Class Summary

Nested classes/interfaces inherited from interface org.apache.cassandra.concurrent.ExecutorPlus

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.apache.cassandra.concurrent.ExecutorPlus

Field Detail

name

metrics

tasks

Method Detail

onCompletion

getMaxTasksQueued

addTask

maybeExecuteImmediately

execute

execute

submit

submit

submit

submit

submit

submit

inExecutor

shutdown

shutdownNow

isShutdown

isTerminated

awaitTermination

getPendingTaskCount

getCompletedTaskCount

getActiveTaskCount

getCorePoolSize

setCorePoolSize

getMaximumPoolSize

setMaximumPoolSize