JAVA-BASED REAL-TIME PROGRAMMING

3. Multi-Threaded Programming
concurrency, like in C/C++. Returning a value from a monitor method often
requires the return value to be declared as an additional local variable, called
ans in the following implementation of the class Account, not permitting the
account to be overdrawn:
1 class Account {
2 int balance;
3 Semaphore mutex = new MutexSem();
4
5 void deposit(int amount) { // As in implemented above.... }
6
7 int withdraw(int amount) {
8 int ans = 0;
9 mutex.take();
10 if (amount > balance) {
11 ans = amount - balance;
12 balance = 0;
13 } else {
14 balance -= amount;
15 }
16 mutex.give();
17 return ans;
18 }
19 }
Based on this code, consider the following:
• Having the local variable ans initialized and returned no longer makes
the semaphore operations that clear as a scope for the critical section.
• Line 8 and 9 could be swapped, technically, but what would happen if
we swap lines 16 and 17?
• If the introduced if-statement would be inserted in a larger method,
there is the risk that lines 10 to 15 would have been implemented as
int withdraw(int amount) {
mutex.take();
if (amount > balance) {
balance = 0;
return amount - balance; // Bug one.
} else {
balance -= amount;
return 0; // Bug two.
}
mutex.give();
}
and the resource would have been locked forever after the first call.
That would be an easy to find bug, but what if the return from inside
the method (between take and give) only occurs in a very special case
as evaluated in a more complex if statement? Deadlock in the shipped
product after a few weeks at the customer site?
• If the ans variable would be declared as an object attribute, like the
balance attribute, we have a concurrency error. Mutual exclusion between
deposit and withdraw still works (since ans is used only by the
68 2012-08-29 16:05