class s1 extends Thread
{
public void run()
{
for(int i = 0; i < 3; i++)
{
System.out.println("A");
System.out.println("B");
}
}
}
class Test120 extends Thread
{
public void run()
{
for(int i = 0; i < 3; i++)
{
System.out.println("C");
System.out.println("D");
}
}
public static void main(String args[])
{
s1 t1 = new s1();
Test120 t2 = new Test120();
t1.start();
t2.start();
}
}
A -
Compile time Error There is no start() method
B -
Will print in this order AB CD AB...
C -
Will print but not be able to predict the Order
D -
Will print in this order ABCD...ABCD...
2-
What will be the output of the program?
class s implements Runnable
{
int x, y;
public void run()
{
for(int i = 0; i < 1000; i++)
synchronized(this)
{
x = 12;
y = 12;
}
System.out.print(x + " " + y + " ");
}
public static void main(String args[])
{
s run = new s();
Thread t1 = new Thread(run);
Thread t2 = new Thread(run);
t1.start();
t2.start();
}
}
A -
DeadLock
B -
It print 12 12 12 12
C -
Compilation Error
D -
Cannot determine output.
3-
What will be the output of the program?
public class ThreadDemo
{
private int count = 1;
public synchronized void doSomething()
{
for (int i = 0; i < 10; i++)
System.out.println(count++);
}
public static void main(String[] args)
{
ThreadDemo demo = new ThreadDemo();
Thread a1 = new A(demo);
Thread a2 = new A(demo);
a1.start();
a2.start();
}
}
class A extends Thread
{
ThreadDemo demo;
public A(ThreadDemo td)
{
demo = td;
}
public void run()
{
demo.doSomething();
}
}
A -
It will print the numbers 0 to 19 sequentially
B -
It will print the numbers 1 to 20 sequentially
C -
It will print the numbers 1 to 20, but the order cannot be determined
D -
The code will not compile.
4-
What will be the output of the program?
public class WaitTest
{
public static void main(String [] args)
{
System.out.print("1 ");
synchronized(args)
{
System.out.print("2 ");
try
{
args.wait(); /* Line 11 */
}
catch(InterruptedException e){ }
}
System.out.print("3 ");
}
}
A -
It fails to compile because the IllegalMonitorStateException of wait() is not dealt with in line 11.
B -
1 2 3
C -
1 3
D -
1 2
5-
What will be the output of the program?
public class SyncTest
{
public static void main (String [] args)
{
Thread t = new Thread()
{
Foo f = new Foo();
public void run()
{
f.increase(20);
}
};
t.start();
}
}
class Foo
{
private int data = 23;
public void increase(int amt)
{
int x = data;
data = x + amt;
}
}
and assuming that data must be protected from corruption, what—if anything—can you add to the preceding code to ensure the integrity of data?
A -
Synchronize the run method.
B -
Wrap a synchronize(this) around the call to f.increase().
C -
The existing code will cause a runtime exception.
D -
Synchronize the increase() method
6-
What will be the output of the program?
class Happy extends Thread
{
final StringBuffer sb1 = new StringBuffer();
final StringBuffer sb2 = new StringBuffer();
public static void main(String args[])
{
final Happy h = new Happy();
new Thread()
{
public void run()
{
synchronized(this)
{
h.sb1.append("A");
h.sb2.append("B");
System.out.println(h.sb1);
System.out.println(h.sb2);
}
}
}.start();
new Thread()
{
public void run()
{
synchronized(this)
{
h.sb1.append("D");
h.sb2.append("C");
System.out.println(h.sb2);
System.out.println(h.sb1);
}
}
}.start();
}
}
A -
ABBCAD
B -
ABCBCAD
C -
CDADACB
D -
Output determined by the underlying platform.
7-
class Test
{
public static void main(String [] args)
{
printAll(args);
}
public static void printAll(String[] lines)
{
for(int i = 0; i < lines.length; i++)
{
System.out.println(lines[i]);
Thread.currentThread().sleep(1000);
}
}
}
the static method Thread.currentThread() returns a reference to the currently executing Thread object. What is the result of this code?
A -
Each String in the array lines will output, with a 1-second pause.
B -
Each String in the array lines will output, with no pause in between because this method is not executed in a Thread.
C -
Each String in the array lines will output, and there is no guarantee there will be a pause because currentThread() may not retrieve this thread.
D -
This code will not compile.
8-
What will be the output of the program?
class MyThread extends Thread
{
public static void main(String [] args)
{
MyThread t = new MyThread(); /* Line 5 */
t.run(); /* Line 6 */
}
public void run()
{
for(int i=1; i < 3; ++i)
{
System.out.print(i + "..");
}
}
}
A -
This code will not compile due to line 5.
B -
This code will not compile due to line 6.
C -
1..2..
D -
1..2..3..
9-
What will be the output of the program?
class Test116
{
static final StringBuffer sb1 = new StringBuffer();
static final StringBuffer sb2 = new StringBuffer();
public static void main(String args[])
{
new Thread()
{
public void run()
{
synchronized(sb1)
{
sb1.append("A");
sb2.append("B");
}
}
}.start();
new Thread()
{
public void run()
{
synchronized(sb1)
{
sb1.append("C");
sb2.append("D");
}
}
}.start(); /* Line 28 */
System.out.println (sb1 + " " + sb2);
}
}
A -
main() will finish before starting threads.
B -
main() will finish in the middle of one thread.
C -
main() will finish after one thread.
D -
Cannot be determined.
10-
What will be the output of the program?
public class ThreadTest extends Thread
{
public void run()
{
System.out.println("In run");
yield();
System.out.println("Leaving run");
}
public static void main(String []argv)
{
(new ThreadTest()).start();
}
}
A -
The code fails to compile in the main() method
B -
The code fails to compile in the run() method
C -
Only the text "In run" will be displayed
D -
The text "In run" followed by "Leaving run" will be displayed
