Filter
Top Products
Chapter 2 Multitasking Safety 7
For example, certain native functions (such as file storage) must be maintained on a
per-application basis. In a single-tasking system, only one application is running,
and so all file access is on behalf of that one application. In a multitasking system,
several applications are running, and so the file access code can no longer assume
that just one application exists. Instead, it must be aware of the possibility of
multiple applications, so that one application doesn't accidentally operate on
another application’s files. Code that is aware of this possibility is multitask safe.
While operations from different tasks can occur in an arbitrary order, no possibility
exists of actual concurrency among native methods. One native thread exists in the
Java Wireless Client software. When it is running a native method, no possibility
exists of a context switch that causes another native method to be run at the same
time. Each native method runs to completion and returns before the next native
method can begin. For this reason, every native method is a critical section, and it is
usually not necessary to perform any OS-level locking (such as with Pthreads
mutexes) in native methods. It is only necessary to use OS-level locking if other
native threads are active in the system while the Java Wireless Client software is
running.
Thus, while native code that runs within Java Wireless Client software must be
multitask safe, it need not be multithread safe.
Global and Static Data
In a single-tasking system, it is common for native code to use global or static
variables. This works because only one application is running at a time. Global data
is implicitly associated with the currently running application. In a multi-tasking
system, the multiple applications likely conflict over global data. Therefore, to make
your code multitask safe, you might need to rearrange your native data to be
allocated on a per-task basis instead of globally.
To do this, you must allocate native data dynamically instead of statically. In
addition, you need to associate each piece of native data with a particular task.
To manage native data on a per-task basis, store a pointer to the native data into an
int field in a Java object. Associating the native resource with a single Java object
implicitly provides multitasking safety because each Java object resides in exactly
one task. It is also a good object-oriented approach.
Create a class to represent the native resource. Give the class a private field to hold
the pointer to the resource, for example:
private int nativePtr;