foo and bar are public references available to many other threads. foo refers to a Thread and bar is an Object. The thread foo is currently executing bar.wait（）. From another thread， which statement is the most reliable way to ensue that foo will stop executing wait（）？ 

void waitForSignal（） { 
Object obj = new Object（）； 
synchronized （Thread.currentThread（）） { 
obj.wait（）； 
obj.notify（）； 
} 
} 
Which is true？（） 

class Computation extends Thread { 
private int num； 
private boolean isComplete； 
private int result； 
public Computation（int num） { this.num = num； } 
public synchronized void run（） { 
result = num * 2； 
isComplete = true； 
notify（）； 
} 
public synchronized int getResult（） { 
while （!isComplete） { 
try { 
wait（）； 
} catch （InterruptedException e） { } 
} 
return result； 
} 
public static void main（String[] args） { 
Computation[] computations = new Computation [4]； 
for （int i = 0； i < computations.length； i++） { 
computations[i] = new Computation（i）； 
computations[i] .start（）； 
} 
for （Computation c ： computations） 
System.out.print（c.getResult（） +“ “）； 
} 
} 
What is the result？（） 

public class Transfers { 
public static void main（String[] args） throws Exception { 
Record r1 = new Record（）； 
Record r2 = new Record（）； 
doTransfer（r1， r2， 5）； 
doTransfer（r2， r1， 2）； 
doTransfer（r1， r2， 1）； 
// print the result 
System.out.println（”rl = “ + r1.get（） +“， r2=” + r2.get（））； 
} 
private static void doTransfer（ 
final Record a， final Record b， final int amount） { 
Thread t = new Thread（） { 
public void run（） { 
new Clerk（）.transfer（a， b， amount）； 
} 
}； 
t.start（）； 
} 
} 
class Clerk { 
public synchronized void transfer（Record a， Record b， int amount）{ 
synchronized （a） { 
synchronized （b） { 
a.add（-amount）； 
b.add（amount）； 
} 
} 
} 
} 
class Record { 
int num=10； 
public int get（） { return num； } 
public void add（int n） { num = num + n； } 
} 
If Transfers.main（） is run， which three are true？（）