BasicExecutionManager (Apache Brooklyn)

java.lang.Object
- brooklyn.util.task.BasicExecutionManager

All Implemented Interfaces:

ExecutionManager
```
public class BasicExecutionManager
extends java.lang.Object
implements ExecutionManager
```
Manages the execution of atomic tasks and scheduled (recurring) tasks, including setting tags and invoking callbacks.

Constructor Summary

Constructors
Constructor and Description

BasicExecutionManager(java.lang.String contextid)

Constructors
Constructor and Description
`BasicExecutionManager(java.lang.String contextid)`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addListener(ExecutionListener listener)`
`java.util.Collection<Task<?>>`	`allTasksLive()` live view of all tasks, for internal use only
`boolean`	`clearTaskSchedulerForTag(java.lang.Object tag)` Forgets that any scheduler was associated with a tag.
`void`	`deleteTag(java.lang.Object tag)` Deletes the given tag, including all tasks using this tag.
`void`	`deleteTask(Task<?> task)`
`java.util.List<Task<?>>`	`getAllTasks()` not on interface because potentially expensive
`long`	`getNumActiveTasks()` count of tasks started but not ended
`long`	`getNumIncompleteTasks()` count of tasks submitted but not ended
`long`	`getNumInMemoryTasks()` count of tasks kept in memory, often including ended tasks
`static java.lang.ThreadLocal<Task<?>>`	`getPerThreadCurrentTask()`
`java.util.concurrent.ConcurrentMap<java.lang.Object,TaskScheduler>`	`getSchedulerByTag()`
`Task<?>`	`getTask(java.lang.String id)` returns the task with the given ID, or null if none
`TaskScheduler`	`getTaskSchedulerForTag(java.lang.Object tag)`
`java.util.Set<Task<?>>`	`getTasksWithAllTags(java.lang.Iterable<?> tags)` only works with at least one tag; returns empty if no tags
`java.util.Set<Task<?>>`	`getTasksWithAnyTag(java.lang.Iterable<?> tags)` returns all tasks that have any of the given tags (immutable)
`java.util.Set<Task<?>>`	`getTasksWithTag(java.lang.Object tag)` returns all tasks with the given tag (immutable)
`java.util.Set<java.lang.Object>`	`getTaskTags()` returns all tags known to this manager (immutable)
`long`	`getTotalTasksSubmitted()` count of all tasks submitted
`boolean`	`isShutdown()`
`void`	`removeListener(ExecutionListener listener)`
`<T> Task<T>`	`scheduleWith(java.util.Map<?,?> flags, Task<T> task)`
`<T> Task<T>`	`scheduleWith(Task<T> task)`
`void`	`setTaskSchedulerForTag(java.lang.Object tag, java.lang.Class<? extends TaskScheduler> scheduler)`
`void`	`setTaskSchedulerForTag(java.lang.Object tag, TaskScheduler scheduler)` Defines a `TaskScheduler` to run on all subsequently submitted jobs with the given tag.
`void`	`shutdownNow()`
`<T> Task<T>`	`submit(java.util.concurrent.Callable<T> c)` see `ExecutionManager.submit(Map, TaskAdaptable)`
`<T> Task<T>`	`submit(java.util.Map<?,?> flags, java.util.concurrent.Callable<T> c)` see `ExecutionManager.submit(Map, TaskAdaptable)`
`Task<?>`	`submit(java.util.Map<?,?> flags, java.lang.Runnable r)` see `ExecutionManager.submit(Map, TaskAdaptable)`
`<T> Task<T>`	`submit(java.util.Map<?,?> flags, TaskAdaptable<T> task)` Submits the given `Task` for execution in the context associated with this manager.
`Task<?>`	`submit(java.lang.Runnable r)` see `ExecutionManager.submit(Map, TaskAdaptable)`
`<T> Task<T>`	`submit(TaskAdaptable<T> t)` see `ExecutionManager.submit(Map, TaskAdaptable)`
`java.util.Set<Task<?>>`	`tasksWithTagLiveOrNull(java.lang.Object tag)` exposes live view, for internal use only

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

- Constructor Detail
  - BasicExecutionManager
```
public BasicExecutionManager(java.lang.String contextid)
```
- Method Detail
  - getPerThreadCurrentTask
```
public static java.lang.ThreadLocal<Task<?>> getPerThreadCurrentTask()
```
  - shutdownNow
```
public void shutdownNow()
```
  - addListener
```
public void addListener(ExecutionListener listener)
```
  - removeListener
```
public void removeListener(ExecutionListener listener)
```
  - deleteTag
```
public void deleteTag(java.lang.Object tag)
```
    Deletes the given tag, including all tasks using this tag. Useful, for example, if an entity is being expunged so that we don't keep holding a reference to it as a tag.
  - deleteTask
```
public void deleteTask(Task<?> task)
```
  - isShutdown
```
public boolean isShutdown()
```
    Specified by:
    
    isShutdown in interface ExecutionManager
  - getTotalTasksSubmitted
```
public long getTotalTasksSubmitted()
```
    count of all tasks submitted
  - getNumIncompleteTasks
```
public long getNumIncompleteTasks()
```
    count of tasks submitted but not ended
  - getNumActiveTasks
```
public long getNumActiveTasks()
```
    count of tasks started but not ended
  - getNumInMemoryTasks
```
public long getNumInMemoryTasks()
```
    count of tasks kept in memory, often including ended tasks
  - tasksWithTagLiveOrNull
```
@Beta
public java.util.Set<Task<?>> tasksWithTagLiveOrNull(java.lang.Object tag)
```
    exposes live view, for internal use only
  - getTask
```
public Task<?> getTask(java.lang.String id)
```
    Description copied from interface: ExecutionManager
    
    returns the task with the given ID, or null if none
    
    Specified by:
    
    getTask in interface ExecutionManager
  - getAllTasks
```
public java.util.List<Task<?>> getAllTasks()
```
    not on interface because potentially expensive
  - getTasksWithTag
```
public java.util.Set<Task<?>> getTasksWithTag(java.lang.Object tag)
```
    Description copied from interface: ExecutionManager
    
    returns all tasks with the given tag (immutable)
    
    Specified by:
    
    getTasksWithTag in interface ExecutionManager
  - getTasksWithAnyTag
```
public java.util.Set<Task<?>> getTasksWithAnyTag(java.lang.Iterable<?> tags)
```
    Description copied from interface: ExecutionManager
    
    returns all tasks that have any of the given tags (immutable)
    
    Specified by:
    
    getTasksWithAnyTag in interface ExecutionManager
  - getTasksWithAllTags
```
public java.util.Set<Task<?>> getTasksWithAllTags(java.lang.Iterable<?> tags)
```
    only works with at least one tag; returns empty if no tags
    
    Specified by:
    
    getTasksWithAllTags in interface ExecutionManager
  - allTasksLive
```
@Beta
public java.util.Collection<Task<?>> allTasksLive()
```
    live view of all tasks, for internal use only
  - getTaskTags
```
public java.util.Set<java.lang.Object> getTaskTags()
```
    Description copied from interface: ExecutionManager
    
    returns all tags known to this manager (immutable)
    
    Specified by:
    
    getTaskTags in interface ExecutionManager
  - submit
```
public Task<?> submit(java.lang.Runnable r)
```
    Description copied from interface: ExecutionManager
    
    see ExecutionManager.submit(Map, TaskAdaptable)
    
    Specified by:
    
    submit in interface ExecutionManager
  - submit
```
public Task<?> submit(java.util.Map<?,?> flags,
             java.lang.Runnable r)
```
    Description copied from interface: ExecutionManager
    
    see ExecutionManager.submit(Map, TaskAdaptable)
    
    Specified by:
    
    submit in interface ExecutionManager
  - submit
```
public <T> Task<T> submit(java.util.concurrent.Callable<T> c)
```
    Description copied from interface: ExecutionManager
    
    see ExecutionManager.submit(Map, TaskAdaptable)
    
    Specified by:
    
    submit in interface ExecutionManager
  - submit
```
public <T> Task<T> submit(java.util.Map<?,?> flags,
                 java.util.concurrent.Callable<T> c)
```
    Description copied from interface: ExecutionManager
    
    see ExecutionManager.submit(Map, TaskAdaptable)
    
    Specified by:
    
    submit in interface ExecutionManager
  - submit
```
public <T> Task<T> submit(TaskAdaptable<T> t)
```
    Description copied from interface: ExecutionManager
    
    see ExecutionManager.submit(Map, TaskAdaptable)
    
    Specified by:
    
    submit in interface ExecutionManager
  - submit
```
public <T> Task<T> submit(java.util.Map<?,?> flags,
                 TaskAdaptable<T> task)
```
    Description copied from interface: ExecutionManager
    Submits the given Task for execution in the context associated with this manager. The following optional flags supported (in the optional map first arg):
    - tag - A single object to be used as a tag for looking up the task
    - tags - A Collection of object tags each of which the task should be associated, used for associating with contexts, mutex execution, and other purposes
    - synchId - A string, or Collection of strings, representing a category on which an object should own a synch lock
    - synchObj - A string, or Collection of strings, representing a category on which an object should own a synch lock
    - newTaskStartCallback - A Closure that will be invoked just before the task starts if it starts as a result of this call
    - newTaskEndCallback - A Closure that will be invoked when the task completes if it starts as a result of this call
    Callbacks run in the task's thread, and if the callback is a Closure it is passed the task for convenience. The closure can be any of the following types; either a Closure, Runnable or Callable.
    If a Map is supplied it must be modifiable (currently; may allow immutable maps in future).
    Specified by:
    
    submit in interface ExecutionManager
  - scheduleWith
```
public <T> Task<T> scheduleWith(Task<T> task)
```
  - scheduleWith
```
public <T> Task<T> scheduleWith(java.util.Map<?,?> flags,
                       Task<T> task)
```
  - getTaskSchedulerForTag
```
public TaskScheduler getTaskSchedulerForTag(java.lang.Object tag)
```
  - setTaskSchedulerForTag
```
public void setTaskSchedulerForTag(java.lang.Object tag,
                          java.lang.Class<? extends TaskScheduler> scheduler)
```
  - setTaskSchedulerForTag
```
public void setTaskSchedulerForTag(java.lang.Object tag,
                          TaskScheduler scheduler)
```
    Defines a TaskScheduler to run on all subsequently submitted jobs with the given tag. Maximum of one allowed currently. Resubmissions of the same scheduler (or scheduler class) allowed. If changing, you must call clearTaskSchedulerForTag(Object) between the two.
    
    See Also:
    setTaskSchedulerForTag(Object, Class)
  - clearTaskSchedulerForTag
```
public boolean clearTaskSchedulerForTag(java.lang.Object tag)
```
    Forgets that any scheduler was associated with a tag.
    
    See Also:
    setTaskSchedulerForTag(Object, TaskScheduler), setTaskSchedulerForTag(Object, Class)
  - getSchedulerByTag
```
public java.util.concurrent.ConcurrentMap<java.lang.Object,TaskScheduler> getSchedulerByTag()
```

Class BasicExecutionManager

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

BasicExecutionManager

Method Detail

getPerThreadCurrentTask

shutdownNow

addListener

removeListener

deleteTag

deleteTask

isShutdown

getTotalTasksSubmitted

getNumIncompleteTasks

getNumActiveTasks

getNumInMemoryTasks

tasksWithTagLiveOrNull

getTask

getAllTasks

getTasksWithTag

getTasksWithAnyTag

getTasksWithAllTags

allTasksLive

getTaskTags

submit

submit

submit

submit

submit

submit

scheduleWith

scheduleWith

getTaskSchedulerForTag

setTaskSchedulerForTag

setTaskSchedulerForTag

clearTaskSchedulerForTag

getSchedulerByTag