What are Callbacks?|
A simple Thread class
A real Thread class
by Jürgen Hermann
last updated 2000/02/16
also available as XML
Many operating systems and other subsystems (like GUI libraries) feature
a special type of hook into those systems, named callbacks or callback
functions. Upon initialization or by calling an API function you pass
pointers to the callback into the subsystem, for later use.
The problem with those functions is, since these subsystems are nowadays
not yet OO, that they have no notion of what an object is. So if you want
to have a callback object instead of a mere function, some
OO magic is called for.
As an example, consider the
BeginThread API that many OSes have
in a quite similar form; we assume that it takes a pointer to the function
that provides the actual code for the newly created thread plus a data
pointer that is passed to that function as a startup parameter. Thus,
we end up with
BeginThread (void (*thread_func) (void*), void* startup_data).
Now let's make a
Thread class of that.
When we put the thread concept into a class, we have to consider lifetime. A
thread exists as long as the thread function does not return, thus the object
has to have the same lifetime. Because of this, an
auto thread object does not
make much sense; we insure that every thread object exists on the heap by making
the ctor protected and providing a static factory method
thread objects in each derived class:
return *new DerivedThread;
create has to be added to every inherited class, returning an object
of that class.
Next, we need a
run method that actually starts the thread.
This can't be done in the ctor: when
code would be registered
as a thread of execution in the base class ctor, the superclass
would not yet be fully created and calling
code would be quite invalid
run does its job by registering the
function as a thread, giving that thread the object pointer as a startup parameter;
dispatch is static, it has a prototype
that matches the
void(*)(void*) parameter of
// Don't start two threads on the same object
if (running) return;
// Create an OS thread, using the static callback
running = 1;
dispatch is called and performs the step from a procedural
callback to the callback object:
void Thread::dispatch(void* thread_obj)
// Call the actual OO thread code
// After code() returns, kill the thread object
This article is Copyright © 1997-98 by Jürgen Hermann
and Copyright © 1999 by C-Scene. All Rights Reserved.