Task

java.lang.Object
- kilim.Task<TT>

All Implemented Interfaces:

java.lang.Runnable, EventSubscriber, Fiber.Worker

Direct Known Subclasses:

Battle.Actor, BigPingPong, Chain, Chain, Continuation.FakeTask, Ex, Jetlang, NioSelectorScheduler.RegistrationTask, PerfTest, Pure.TaskDemo, Rec, Reflect, Ring, SessionTask, SimpleTask, SimpleTask2, Sleep, Task.Fork, Task.Invoke, Task.Spawn, TaskGroup, TimedTask, TimerBlast, TimerBlast.Tick, TimerBlast2.Tick, TimerBlast2.Tock, Unwind, Userdata
```
public abstract class Task<TT>
extends java.lang.Object
implements java.lang.Runnable, EventSubscriber, Fiber.Worker
```
A base class for tasks. A task is a lightweight thread (it contains its own stack in the form of a fiber). A concrete subclass of Task must provide a pausable execute method.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class Task.Fork

static class Task.Invoke<TT>

static class Task.Spawn<TT>

Nested Classes
Modifier and Type	Class and Description
`static class`	`Task.Fork`
`static class`	`Task.Invoke<TT>`
`static class`	`Task.Spawn<TT>`

Field Summary

Fields
Modifier and Type	Field and Description
`protected boolean`	`done`
`java.lang.Object`	`exitResult`
`protected Fiber`	`fiber` The stack manager in charge of rewinding and unwinding the stack when Task.pause() is called.
`int`	`id` Task id, automatically generated
`protected PauseReason`	`pauseReason` The reason for pausing (duh) and performs the role of a await condition in CCS.
`protected java.util.concurrent.atomic.AtomicBoolean`	`running` running = true when it is put on the schdulers run Q (by Task.resume()).
`protected Scheduler`	`scheduler` The object responsible for handing this task to a thread when the task is runnable.
`Timer`	`timer`

Constructor Summary

Constructors
Constructor and Description

Task()

Constructors
Constructor and Description
`Task()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`checkKill()`
`java.lang.String`	`dump()`
`boolean`	`equals(java.lang.Object obj)`
`static void`	`errNotWoven()`
`static void`	`errNotWoven(Task t)`
`static void`	`errorExit(java.lang.Throwable ex)` Exit the task with a throwable indicating an error condition.
`static void`	`errorExit(java.lang.Throwable ex, Fiber f)`
`void`	`execute()`
`void`	`execute(Fiber f)`
`static void`	`exit(java.lang.Object aExitValue)` Analogous to System.exit, except an Object can be used as the exit value
`static void`	`exit(java.lang.Object aExitValue, Fiber f)`
`static Task`	`fork(Pausable.Fork body)` Wraps the given object or lambda expression in a Task and starts that task.
`static Task`	`getCurrentTask()` This is a placeholder that doesn't do anything useful.
`java.lang.Thread`	`getExecutionThread()`
`PauseReason`	`getPauseReason()`
`Scheduler`	`getScheduler()`
`static int`	`getStackDepth(Task task)` The generated code calls Fiber.upEx, which in turn calls this to find out out where the current method is w.r.t the closest _runExecute method.
`boolean`	`getState()`
`int`	`getTid()` return the thread ID that the task is currently running on, valid only during execute
`int`	`hashCode()`
`int`	`id()`
`static void`	`idledown()` idledown the default scheduler
`void`	`informOnExit(Mailbox<ExitMsg<TT>> exit)`
`static java.lang.Object`	`invoke(java.lang.reflect.Method method, java.lang.Object obj, java.lang.Object... args)` Invoke a pausable method via reflection.
`boolean`	`isDone()`
`ExitMsg<TT>`	`join()`
`ExitMsg<TT>`	`joinb()`
`void`	`onEvent(EventPublisher ep, Event e)`
`static void`	`pause(PauseReason pauseReason)` Ask the current task to pause with a reason object, that is responsible for resuming the task when the reason (for pausing) is not valid any more.
`static void`	`pause(PauseReason pauseReason, Fiber f)`
`void`	`pinToThread()`
`void`	`prePin()`
`boolean`	`resume()` Add itself to scheduler if it is neither already running nor done.
`void`	`resumeOnScheduler(Scheduler s)`
`void`	`run()` Called by WorkerThread, it is the wrapper that performs pre and post execute processing (in addition to calling the execute(fiber) method of the task.
`protected void`	`setPauseReason(PauseReason pr)`
`Task<TT>`	`setScheduler(Scheduler s)`
`protected void`	`setTid(int tid)`
`static void`	`shutdown()`
`static void`	`sleep(long millis)`
`static Task.Invoke`	`spawn(java.lang.reflect.Method method, java.lang.Object obj, java.lang.Object... args)`
`static <TT> Task.Spawn<TT>`	`spawn(Pausable.Spawn<TT> body)` Wraps the given object or lambda expression in a Task and starts that task.
`Task<TT>`	`start()` Used to start the task; the task doesn't resume on its own.
`java.lang.String`	`toString()`
`void`	`unpinFromThread()`
`static void`	`yield()` Yield cooperatively to the next task waiting to use the thread.
`static void`	`yield(Fiber f)`

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

- Field Detail
  - id
```
public final int id
```
    Task id, automatically generated
  - fiber
```
protected Fiber fiber
```
    The stack manager in charge of rewinding and unwinding the stack when Task.pause() is called.
  - pauseReason
```
protected PauseReason pauseReason
```
    The reason for pausing (duh) and performs the role of a await condition in CCS. This object is responsible for resuming the task.
    
    See Also:
    
    PauseReason
  - running
```
protected java.util.concurrent.atomic.AtomicBoolean running
```
    running = true when it is put on the schdulers run Q (by Task.resume()). The Task.runExecute() method is called at some point; 'running' remains true until the end of runExecute (where it is reset), at which point a fresh decision is made whether the task needs to continue running.
  - done
```
protected volatile boolean done
```
  - scheduler
```
protected Scheduler scheduler
```
    The object responsible for handing this task to a thread when the task is runnable.
  - exitResult
```
public volatile java.lang.Object exitResult
```
  - timer
```
public Timer timer
```
- Constructor Detail
  - Task
```
public Task()
```
- Method Detail
  - id
```
public int id()
```
  - setScheduler
```
public Task<TT> setScheduler(Scheduler s)
```
  - getScheduler
```
public Scheduler getScheduler()
```
  - resumeOnScheduler
```
public void resumeOnScheduler(Scheduler s)
                       throws Pausable
```
    Throws:
    
    Pausable
  - start
```
public Task<TT> start()
```
    Used to start the task; the task doesn't resume on its own. Custom schedulers must be set (@see #setScheduler(Scheduler)) before start() is called.
    
    Returns:
  - getStackDepth
```
public static int getStackDepth(Task task)
```
    The generated code calls Fiber.upEx, which in turn calls this to find out out where the current method is w.r.t the closest _runExecute method.
    
    Returns:
    
    the number of stack frames above _runExecute(), not including this method
  - onEvent
```
public void onEvent(EventPublisher ep,
                    Event e)
```
    Specified by:
    
    onEvent in interface EventSubscriber
  - getExecutionThread
```
public java.lang.Thread getExecutionThread()
```
  - resume
```
public boolean resume()
```
    Add itself to scheduler if it is neither already running nor done.
    
    Returns:
    
    True if it scheduled itself.
  - informOnExit
```
public void informOnExit(Mailbox<ExitMsg<TT>> exit)
```
  - getCurrentTask
```
public static Task getCurrentTask()
                           throws Pausable
```
    This is a placeholder that doesn't do anything useful. Weave replaces the call in the bytecode from invokestateic Task.getCurrentTask to load fiber getfield task
    
    Throws:
    
    Pausable
  - exit
```
public static void exit(java.lang.Object aExitValue)
                 throws Pausable
```
    Analogous to System.exit, except an Object can be used as the exit value
    
    Throws:
    
    Pausable
  - exit
```
public static void exit(java.lang.Object aExitValue,
                        Fiber f)
```
  - errorExit
```
public static void errorExit(java.lang.Throwable ex)
                      throws Pausable
```
    Exit the task with a throwable indicating an error condition. The value is conveyed through the exit mailslot (see informOnExit). All exceptions trapped by the task scheduler also set the error result.
    
    Throws:
    
    Pausable
  - errorExit
```
public static void errorExit(java.lang.Throwable ex,
                             Fiber f)
```
  - errNotWoven
```
public static void errNotWoven()
```
  - errNotWoven
```
public static void errNotWoven(Task t)
```
  - invoke
```
public static java.lang.Object invoke(java.lang.reflect.Method method,
                                      java.lang.Object obj,
                                      java.lang.Object... args)
                               throws Pausable,
                                      java.lang.IllegalAccessException,
                                      java.lang.IllegalArgumentException,
                                      java.lang.reflect.InvocationTargetException
```
    Invoke a pausable method via reflection. Equivalent to Method.invoke().
    
    Parameters:
    
    method - : The method to be invoked. (Implementation note: the corresponding woven method is invoked instead).
    
    obj - : The object on which the method is invoked. Can be null if the method is static.
    
    args - : Arguments to the method
    
    Returns:
    
    Throws:
    
    Pausable
    
    java.lang.IllegalAccessException
    
    java.lang.IllegalArgumentException
    
    java.lang.reflect.InvocationTargetException
  - sleep
```
public static void sleep(long millis)
                  throws Pausable
```
    Parameters:
    
    millis - to sleep. Like thread.sleep, except it doesn't throw an interrupt, and it doesn't hog the java thread.
    
    Throws:
    
    Pausable
  - shutdown
```
public static void shutdown()
```
  - yield
```
public static void yield()
                  throws Pausable
```
    Yield cooperatively to the next task waiting to use the thread.
    
    Throws:
    
    Pausable
  - yield
```
public static void yield(Fiber f)
```
  - pause
```
public static void pause(PauseReason pauseReason)
                  throws Pausable
```
    Ask the current task to pause with a reason object, that is responsible for resuming the task when the reason (for pausing) is not valid any more.
    
    Parameters:
    
    pauseReason - the reason
    
    Throws:
    
    Pausable
  - pause
```
public static void pause(PauseReason pauseReason,
                         Fiber f)
```
  - execute
```
public void execute()
             throws Pausable,
                    java.lang.Exception
```
    Specified by:
    
    execute in interface Fiber.Worker
    
    Throws:
    
    Pausable
    
    java.lang.Exception
  - execute
```
public void execute(Fiber f)
             throws java.lang.Exception
```
    Specified by:
    
    execute in interface Fiber.Worker
    
    Throws:
    
    java.lang.Exception
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - dump
```
public java.lang.String dump()
```
  - prePin
```
public void prePin()
            throws Pausable
```
    Throws:
    
    Pausable
  - pinToThread
```
public void pinToThread()
```
  - unpinFromThread
```
public void unpinFromThread()
```
  - setPauseReason
```
protected final void setPauseReason(PauseReason pr)
```
  - getPauseReason
```
public final PauseReason getPauseReason()
```
  - isDone
```
public boolean isDone()
```
  - setTid
```
protected void setTid(int tid)
```
  - getTid
```
public int getTid()
```
    return the thread ID that the task is currently running on, valid only during execute
  - run
```
public void run()
         throws NotPausable
```
    Called by WorkerThread, it is the wrapper that performs pre and post execute processing (in addition to calling the execute(fiber) method of the task.
    
    Specified by:
    
    run in interface java.lang.Runnable
    
    Throws:
    
    NotPausable
  - joinb
```
public ExitMsg<TT> joinb()
```
  - join
```
public ExitMsg<TT> join()
                 throws Pausable
```
    Throws:
    
    Pausable
  - equals
```
public boolean equals(java.lang.Object obj)
```
    Overrides:
    
    equals in class java.lang.Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
  - checkKill
```
public void checkKill()
```
  - getState
```
public boolean getState()
```
  - fork
```
public static Task fork(Pausable.Fork body)
```
    Wraps the given object or lambda expression in a Task and starts that task. Beware of inadvertent sharing when multiple lambdas are created in the same context
    
    Parameters:
    
    body - the lambda to delegate to
    
    Returns:
    
    the spawned task.
  - spawn
```
public static <TT> Task.Spawn<TT> spawn(Pausable.Spawn<TT> body)
```
    Wraps the given object or lambda expression in a Task and starts that task. Beware of inadvertent sharing when multiple lambdas are created in the same context
    
    Parameters:
    
    body - the lambda to delegate to
    
    Returns:
    
    the spawned task.
  - spawn
```
public static Task.Invoke spawn(java.lang.reflect.Method method,
                                java.lang.Object obj,
                                java.lang.Object... args)
```
  - idledown
```
public static void idledown()
```
    idledown the default scheduler
    
    See Also:
    
    Scheduler.idledown()

Class Task<TT>

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

id

fiber

pauseReason

running

done

scheduler

exitResult

timer

Constructor Detail

Task

Method Detail

id

setScheduler

getScheduler

resumeOnScheduler

start

getStackDepth

onEvent

getExecutionThread

resume

informOnExit

getCurrentTask

exit

exit

errorExit

errorExit

errNotWoven

errNotWoven

invoke

sleep

shutdown

yield

yield

pause

pause

execute

execute

toString

dump

prePin

pinToThread

unpinFromThread

setPauseReason

getPauseReason

isDone

setTid

getTid

run

joinb

join

equals

hashCode

checkKill

getState

fork

spawn

spawn

idledown