Filter
Top Products
16 Multitasking Guide • May 2007
The lock() and unlock() static methods were added to the Microwave class to
protect the context that was being built implicitly in library static data by the
setTime() and setPower() methods. This locking protocol effectively provides
mutual exclusion around library static data. This works in a single-tasking
environment, but it fails in a multitasking environment, as described earlier.
If the setup methods simply set values into Java variables, and these values are set
into the library immediately before the call to mw_cook(), a locking protocol that
makes the setup calls and the cook call atomic is no longer necessary. This technique
doesn't work in a multitasking environment anyway. Therefore, it must be removed.
The setup context logically belongs to the calling thread. Multiple threads could
lock, wait, and notify over static data, but this too is no longer necessary if each
thread is permitted to operate on its own instance of a Microwave object.
After making these changes, the resulting Java code is shown in
CODE EXAMPLE 2-8.
CODE EXAMPLE 2-8 Keeping State in Java Code
public class Microwave {
int nsecs;
int power;
private int nativePtr;
public void setTime(int nsecs) {
// error checking elided for brevity
this.nsecs = nsecs;
}
public void setPower(int power) {
// error checking elided for brevity
this.power = power;
}
public int cook() {
init();
return n_cook();
}
private native void init();
private native void n_cook();
public Microwave() { } /* allow instance creation */
private native void finalize();
}
The responsibility of the n_cook() native method is now much greater. It must
block the calling thread until any other cooking operation has completed. It must
retrieve the field values from the object and set them into the library. Finally, it must
block until this cooking operation has completed. Note that to avoid race conditions,
all of this must be performed by a single native method.