The Start function creates a new invocation of the Task Model.  Start creates a root task and then starts executing tasks until the current invocation exits, either because the all the tasks complete or because the Return function is called.  The return value of Start is the value returned by the final task or the value passed into Return.

The Start function is part of the Task Programming Model.

If no child tasks are specified, then Start creates one task which evaluates fnc( args11...argsN ).  

If child tasks are specified, then Start creates one task for each child, and a continuation task with fnc as the continuation function. The value of fnc is either a procedure or the name of a predefined continuation function.

The two predefined continuation functions are passed and null

passed returns the arguments that were passed into it.

null returns NULL.

An argument to Start of the form

Task = [ cfcn, carg1 ... cargn ]

creates a child task that executes the following command.

cfcn( carg1 ... cargn )

An argument to Start of the form:

Tasks = [ cfcn, [c1args] ... [cnargs] ]

behaves as if multiple Task arguments of the form

Task = [ cfcn, c1args ], Task = [ cfcn, c2args ], ... Task = [ cfcn, cnargs ]

had been given.  Thus, it creates tasks to execute the following commands.

cfcn( c1args ), cfcn( c2args ) ... cfcn( cnargs )

The return value of a child task is passed to the continuation function in the child's position in its argument sequence.

Arguments not of the form described above are passed to the continuation function fcn as arguments in the corresponding positions.

If child tasks are created as part of the call to Start, the continuation task will not start executing until all of its child tasks have completed.

with(Threads[Task]);
cont := proc( a, b )
   return a + b;
end proc;

$\left[\mathrm{Continue}\,\mathrm{Return}\,\mathrm{Start}\right]$

$\mathrm{cont}≔\mathbf{proc}\left(a\,b\right)\mathbf{return}a\+b\mathbf{end\; proc}$

task := proc( i, j )
   local k;
   if ( j-i < 1000 ) then
       return add( k, k=i..j );
   else
       k := floor( (j-i)/2 )+i;
       Continue( cont, Task=[ task, i, k ], Task=[ task, k+1, j ] );
   end if;
end proc;

$\mathrm{task}≔\mathbf{proc}\left(i\&comma;j\right)\mathbf{local}k\&semi;\mathbf{if}j-i<1000\mathbf{then}\mathbf{return}\mathrm{add}\left(k\&comma;k\&equals;i..j\right)\mathbf{else}k≔\mathrm{floor}\left(1\&sol;2\&ast;j-1\&sol;2\&ast;i\right)\&plus;i\&semi;\mathrm{Threads}:-\mathrm{Task}:-\mathrm{Continue}\left(\mathrm{cont}\&comma;\mathrm{Task}\&equals;\left[\mathrm{task}\&comma;i\&comma;k\right]\&comma;\mathrm{Task}\&equals;\left[\mathrm{task}\&comma;k\&plus;1\&comma;j\right]\right)\mathbf{end\; if}\mathbf{end\; proc}$

$\mathrm{Start}\left(\mathrm{task}\&comma;1\&comma;{10}^7\right)$

$50000005000000$

$\mathrm{Start}\left(\mathrm{cont}\&comma;\mathrm{Task}=\left[\mathrm{task}\&comma;1\&comma;5{10}^6\right]\&comma;\mathrm{Task}=\left[\mathrm{task}\&comma;5{10}^6+1\&comma;{10}^7\right]\right)$

$50000005000000$

$\mathrm{Start}\left(\mathrm{cont}\&comma;\mathrm{Tasks}=\left[\mathrm{task}\&comma;\left[1\&comma;5{10}^6\right]\&comma;\left[5{10}^6+1\&comma;{10}^7\right]\right]\right)$

$50000005000000$

$\mathrm{add}\left(i\&comma;i=1..{10}^7\right)$

$50000005000000$

The Threads[Task][Start] command was updated in Maple 15.