Re: multitasking: finishing execution

["chris.danx" <spamoff.danx@ntlworld.com>]

"Nige" <nigel.scott@uk.thalesgroup.com> wrote in message
news:3D11CF27.90401@uk.thalesgroup.com...

> select
>     accept Finish;
> else
>     -- do code
>     ....
> end select;
>
> will only process the accept if there is an outstanding call to it.

If a handler calls Finish will it wait indefinitely for the task to accept
it?  That was the original question, although in retrospect the first post
was just confusing.


The problem involves a window and two tasks, a watcher and a builder.  A
watcher scans the keyboard, placing any keypresses corresponding to commands
into a protected object, unless Finish is called at which point the watcher
terminates.  The builder retrieves a keypress from the protected object and
does some processing with it until it recieves a call to Finish, when it
terminates.

Upon creation of the window, a handler 'on_create' starts both tasks.  When
the user quits the application (more precisely closes a window, which in
this case happens to be the main window) the on_destroy handler terminates
the task.

My concern is what would happen if the call to the Finish was not accepted
before any time limit expired.  Cohen states that a task must finish
execution before a program can terminate (which makes sense), if the call
wasn't accepted and subsequenctly abandoned the program would fail to
terminate.

If the builder processes information too quickly, any animation will be done
and over with before the user realises it (also if the redraw method is
called continuously it will crash the system, which happened when I forgot
to clear the flag which records if a keypress is available).  To alleviate
this problem a delay alternative has been added to the code, which waits
around 20ms before doing any processing.  (A better solution might be to use
a protected object describing the state and another task which translates
this and draws it to the screen, but this is just practise with tasks and
gwindows before the main project).

If a call to an entry is placed after the delay alternative expires will the
entry succeed (be accepted by the task) in the next iteration (assuming the
next iteration is free to proceed)?  I think it will since entries queue,
but just want to make sure.


Thanks,
Chris