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？（）

public class TestSeven extends Thread { 
private static int x； 
public synchronized void doThings（） { 
int current = x； 
current++； 
x = current； 
} 
public void run（） { 
doThings（）； 
} 
} 
Which is true？（） 

Which three will compile and rim without exception？（）

public class TestFive { 
private int x； 
public void foo（） { 
int current = x； 
x = current + 1； 
} 
public void go（） { 
for（int i=0；i<5；i++） { 
new Thread（） { 
public void run（） { 
foo（）； 
System.out.print（x + “， “）； 
} }.start（）； 
}}} 
Which two changes， taken together， would guarantee the output： 1， 2， 3， 4， 5， ？（）

import java.util.*； 
public class NameList { 
private List names = new ArrayList（）； 
public synchronized void add（String name） { names.add（name）； } 
public synchronized void printAll（） { 
for （int i = 0； i System.out.print（names.get（i） +“ “）；
} 
} 
public static void main（String[] args） { 
final NameList sl = new NameList（）； 
for（int i=0；i<2；i++） { 
new Thread（） { 
public void ruin（） { 
sl.add（”A”）； 
sl.add（”B”）； 
sl.add（”C”）； 
sl.printAll（）； 
} 
}.start（）； 
} 
} 
} 
Which two statements are true if this class is compiled and run？（）
 

public class Threads 1 { 
intx=0； 
public class Runner implements Runnable { 
public void run（） { 
int current = 0； 
for（int=i=0；i<4；i++）{ 
current = x； 
System.out.print（current + “， “）； 
x = current + 2； 
} 
} 
} 
public static void main（String[] args） { 
new Threads1（）.go（）； 
} 
public void go（） { 
Runnable r1 = new Runner（）； 
new Thread（r1）.start（）； 
new Thread（r1 ）.start（）； 
} 
} 
Which two are possible results？（）

public class NamedCounter { 
private final String name； 
private int count； 
public NamedCounter（String name） { this.name = name； } 
public String getName（） { return name； } 
public void increment（） { coount++； } 
public int getCount（） { return count； }
public void reset（） { count = 0； } } 
Which three changes should be made to adapt this class to be used safely by multiple threads？ （）

public class TwoThreads { 
private static Object resource = new Object（）； 
private static void delay（long n） { 
try { Thread.sleep（n）； } 
catch （Exception e） { System.out.print（”Error “）； } 
} 
public static void main（String[] args） { 
System.out.print（”StartMain “）； 
new Thread1（）.start（）； 
delay（1000）； 
Thread t2 = new Thread2（）； 
t2.start（）； 
delay（1000）； 
t2.interrupt 
delay（1000）； 
System.out.print（”EndMain “）； 
} 
static class Thread 1 extends Thread { 
public void run（） { 
synchronized （resource） { 
System.out.print（”Startl “）； 
delay（6000）； 
System.out.print（”End1 “）； 
} 
} 
} 
static class Thread2 extends Thread { 
public void run（） { 
synchronized （resource） { 
System.out.print（”Start2 “）； 
delay（2000）； 
System.out.print（”End2 “）； 
} 
} 
} 
} 
Assume that sleep（n） executes in exactly m milliseconds， and all other code executes in an insignificant amount of time. What is the output if the main（） method is run？（）