JAVA-BASED REAL-TIME PROGRAMMING

3.3. Objects providing mutual exclusion – Monitors
outside the monitor class, you better use a private lock object which is
locked by a synchronized block in each monitor operation. A monitor
then looks like:
public class RobustMonitorExample {
private Object lock = new Object();
// More attributes are declared here ....
}
public void methodOne(int x) {
synchronized(lock) {
// Attributes are accessed here....
}
}
This way, other objects cannot interfere with the synchronization. Again,
the unfortunate Java design decision to support synchronized blocks but
not synchronized classes with appropriate semantics causes extra trouble
when developing reliable software. Still, the situation is better than
in other major languages. Recall this item when reading about wait and
notify below. Another example will be the non-native Java implementation
of semaphores.
3. Do not synchronize on public attributes. That is, if you (against the
general guideline) synchronize on an attribute like the lock in the previous
item, that attribute should be private or final. Otherwise, that
object reference may change from one synchronization point to another,
thereby removing the synchronization. Locking cannot be ensured if the
look can replaced by anyone.
4. Do not remove synchronization by subclassing (unless it is a final class
and you really know what you are doing). If a base class declares a
method as synchronized, the subclass should do so too. There is nothing
in Java enforcing such a practice, and you might want to optimize
methods in a subclass by omitting synchronized, but the risk for hardto-find
concurrency errors normally is too high considering the interplay
between monitor methods.
5. If synchronization is needed between multiple monitors, such as interconnected
buffers, they of course need an object in common to synchronize
on. An alternative would be to merge the different monitors to form one
monitor with all the functionality included, but suitable monitor classes
may be available already; just the signaling and mutual exclusion between
them need to be added. Using synchronized blocks to synchronize
on some shared lock object (such as one of the monitors if that code has
been prepared for it) is clearly preferable compared to rewriting the
application.
As mentioned in the last item, the need for synchronization between objects
can be due to the need for signaling (which we earlier accomplished
73