| Thinking in C++ Vol 2 - Practical Programming |
|
Prev |
Home |
Next |
Entrance::run( ) in the previous
example includes a call to sleep( ) in the main loop. We know that sleep( )
will eventually wake up and the task will reach the top of the loop where it
has an opportunity to break out of that loop by checking the isPaused( )
status. However, sleep( ) is just one situation where a thread is blocked
from executing, and sometimes you must terminate a task that s blocked.
Thread states
A thread can be in any one of four states:
1. New: A thread remains in this state only momentarily, as
it is being created. It allocates any necessary system resources and performs
initialization. At this point it becomes eligible to receive CPU time. The
scheduler will then transition this thread to the runnable or blocked
state.
2. Runnable: This means that a thread can be run when
the time-slicing mechanism has CPU cycles available for the thread. Thus, the
thread might or might not be running at any moment, but there s nothing to
prevent it from being run if the scheduler can arrange it; it s not dead or
blocked.
3. Blocked: The thread could be run, but something prevents
it. (It might be waiting for I/O to complete, for example.) While a thread is
in the blocked state, the scheduler will simply skip it and not give it any CPU
time. Until a thread reenters the runnable state, it won t perform any
operations.
4. Dead: A thread in the dead state is no longer schedulable
and will not receive any CPU time. Its task is completed, and it is no longer runnable.
The normal way for a thread to die is by returning from its run( ) function.
Becoming blocked
A thread is blocked when it cannot continue running. A
thread can become blocked for the following reasons:
You ve put the thread to sleep by calling sleep(milliseconds),
in which case it will not be run for the specified time.
You ve suspended the execution of the thread with wait( ).
It will not become runnable again until the thread gets the signal( )
or broadcast( ) message. We ll examine these in a later section.
The thread is waiting for some I/O to complete.
The thread is trying to enter a block of code that is guarded by
a mutex, and that mutex has already been acquired by another thread.
The problem we need to look at now is
this: sometimes you want to terminate a thread that is in a blocked state.
If you can t wait for it to get to a point in the code where it can check a
state value and decide to terminate on its own, you have to force the thread
out of its blocked state.
| Thinking in C++ Vol 2 - Practical Programming |
|
Prev |
Home |
Next |
