Filter
Top Products
Chapter 2 Multitasking Safety 13
This API is now multithread safe. However, it is not multitask safe. The reason is
that the thread safety properties are achieved using mechanisms that belong to the
Microwave class. These include static variables (initialized, owner) of the
Microwave class. Thread synchronization and wait and notify operations use the
monitor lock owned by the class. All of these mechanisms are visible to the threads
of a single task, and thus they provide safety among the multiple threads of a single
task.
However, in a multitasking environment, the class static variables and monitor lock
are replicated in each task. Thus, if a thread in task A is performing an operation on
the Microwave class, the initialized variable is true and the owner variable
contains a reference to the thread performing the operation. However, in task B, the
initialized variable still has the value false and the owner variable is null.If
a thread in task B attempts an operation, it takes the lock (even though a thread in
task A “owns” the lock in task A), it calls init() for the first time (from its point of
view). This results in a second call to the native mw_init() function, which is an
error. The thread in task B then calls some of the setup functions and then calls
cook(), possibly before the cook operation initiated from task A completes, which
is another error.
Multitask Safety
Use the microwave library and the Java programming language interface to
illustrate how a library must be changed to be multitask safe.
The first and simplest case is class data (static variables) that is semantically global
but is replicated into each task. Sometimes the singleton pattern is used in this
fashion. Inspect each singleton Java class to determine whether it needs to be a
singleton only from the point of view of Java threads that have access to it, or
whether it needs to be a system-wide singleton. In the former case, ordinary
singleton classes are sufficient. Even though they are replicated within each task,
they can be per-task singletons because each Java thread sees only one instance of the
singleton class. In the latter case, for global singletons, the singleton characteristic
must apply to the entire system. The typical way to accomplish this is to migrate the
relevant data from Java code into native code.
In our example, the global singleton data is a static boolean variable
initialized that indicates whether the microwave library has been initialized.
This can simply be migrated to an int variable in native code. Once this variable is
in native code, it is visible to all tasks using native methods. You can write native
methods to set and get this value and take action as appropriate. This technique is
illustrated in
CODE EXAMPLE 2-6.