Chapter 1

In active objects, higher priority means simply that you get handled sooner than others, if
your event completes along with several others during the handling of the previous RunL().
But active object priority does not cause preemption: if the previous RunL() takes a long
time, nothing you can do with active object priority will get you scheduled sooner.
Important
Make sure that you understand what active object priority means and
be sensible in allocating active object priorities.
So, if you try to use an ultra-high-priority event to do something that requires a certain
response time, it won't always work. An active object used to keep a sound channel going,
say, could get held up behind a step in a long-running task doing printing or database
compaction. In other words, you can't use high-priority active objects to achieve responses
that must occur within a certain time of an event. For that, you need to use the Symbian OS
preemptive thread system, appropriate buffering, and appropriate thread priorities.
17.4 Summary
Symbian OS has a highly responsive preemptive multithreaded architecture. However, most
application and server tasks are by nature event handlers and active objects are a very
suitable paradigm with which to handle events.
Because they are non-preemptive, it's very easy to program with active objects, because
you don't need to code mutual exclusion with other threads trying to access the same
resources.
Active objects also use fewer system resources than full-blown threads: thread overheads
start around 4 k kernel-side and 12 k for the user- side stack, whereas active objects need
be only a few bytes in size. Additionally, switching between active objects is much cheaper
than switching between threads, even in the same process. The time difference can be up to
a factor 10.
This combination of ease of use and low resource requirement is a major factor in the overall
efficiency of Symbian OS. However, performance can be impaired if there are many active
objects since the active scheduler needs to iterate through the list of active objects to find
which object's RunL() to call.
For some purposes, threads are necessary. In the next chapter, we'll include them as we
discuss the Symbian OS client-server architecture.