JAVA-BASED REAL-TIME PROGRAMMING

class Account {
int balance;
Semaphore mutex = new MutexSem();
void deposit(int amount) {
mutex.take();
balance += amount;
mutex.give();
}
void withdraw(int amount) {
mutex.take();
balance -= amount;
mutex.give();
}
}
3.3. Objects providing mutual exclusion – Monitors
class Account {
int balance;
synchronized void deposit(int amount) {
balance += amount;
}
synchronized void withdraw(int amount) {
balance -= amount;
}
}
Figure 3.6: The bank account class to the left uses a semaphore for locking
the object to accomplish mutual exclusion. By declaring the methods synchronized,
as to the right, the same thing is achieved but in a simpler and
more readable manner. In Java, there is an invisible lock in every object.
is the topic of the next section, here we consider the case when concurrently
executing threads actually need to call methods of the same object.
Similar to when we use a MutexSem as a lock to provide exclusive access to
an object, we need some kind of lock also when methods are synchronized. In
Java, there is such a lock available in each object, even for the ordinary ones!
The synchronized keyword tells the compiler to generate code that uses the
lock. Thereby, the program gets more easy to read and write. For instance,
consider the bank account in Figure 3.6.
Synchronized blocks
While the use of synchronized methods improves readability (compared to
the use of semaphores), Java also provides a less (compared to proper use of
monitors) structured alternative for locking an object; the synchronized block.
Within the braces the object obj is locked for exclusive use:
synchronized(obj) { /* Exclusive access to obj here.. */ }
Of course, a synchronized block uses the same object lock as the synchronized
methods of that object, thereby making the block and the methods mutually
exclusive. A synchronized method is equivalent to a method with the
outermost block
{ synchronized(this) { /* Method body here. */ } }
The benefit of language support
Both synchronized methods and blocks are very convenient when returning
from a method. Compare this with the use of semaphores which resembles
the situation when the language/compiler does not support synchronization or
67