Discussion
Home ‣ Java Programming ‣ Threads Comments
- Question
The static method Thread.currentThread() returns a reference to the currently executing Thread object. What is the result of this code?
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); } } }
Options- 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.
- Correct Answer
- This code will not compile.
Explanation
D. The sleep() method must be enclosed in a try/catch block, or the method printAll() must declare it throws the InterruptedException.A is incorrect, but it would be correct if the InterruptedException was dealt with.
B is incorrect, but it would still be incorrect if the InterruptedException was dealt with because all Java code, including the main() method, runs in threads.
C is incorrect. The sleep() method is static, so even if it is called on an instance, it still always affects the currently executing thread.
- 1. 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(); } }
Options- A. DeadLock
- B. It print 12 12 12 12
- C. Compilation Error
- D. Cannot determine output. Discuss
- 2. What will be the output of the program?
class s1 implements Runnable { int x = 0, y = 0; int addX() {x++; return x;} int addY() {y++; return y;} public void run() { for(int i = 0; i < 10; i++) System.out.println(addX() + " " + addY()); } public static void main(String args[]) { s1 run1 = new s1(); s1 run2 = new s1(); Thread t1 = new Thread(run1); Thread t2 = new Thread(run2); t1.start(); t2.start(); } }
Options- A. Compile time Error: There is no start() method
- B. Will print in this order: 1 1 2 2 3 3 4 4 5 5...
- C. Will print but not exactly in an order (e.g: 1 1 2 2 1 1 3 3...)
- D. Will print in this order: 1 2 3 4 5 6... 1 2 3 4 5 6... Discuss
- 3. What will be the output of the program?
class MyThread extends Thread { public static void main(String [] args) { MyThread t = new MyThread(); t.start(); System.out.print("one. "); t.start(); System.out.print("two. "); } public void run() { System.out.print("Thread "); } }
Options- A. Compilation fails
- B. An exception occurs at runtime.
- C. It prints "Thread one. Thread two."
- D. The output cannot be determined. Discuss
- 4. 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); } }
Options- 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. Discuss
- 5. What will be the output of the program?
public class Test { public static void main (String [] args) { final Foo f = new Foo(); Thread t = new Thread(new Runnable() { public void run() { f.doStuff(); } }); Thread g = new Thread() { public void run() { f.doStuff(); } }; t.start(); g.start(); } } class Foo { int x = 5; public void doStuff() { if (x < 10) { // nothing to do try { wait(); } catch(InterruptedException ex) { } } else { System.out.println("x is " + x++); if (x >= 10) { notify(); } } } }
Options- A. The code will not compile because of an error on notify(); of class Foo.
- B. The code will not compile because of some other error in class Test.
- C. An exception occurs at runtime.
- D. It prints "x is 5 x is 6". Discuss
- 6. 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(); } }
Options- 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 Discuss
- 7. What will be the output of the program?
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(); } }
Options- 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... Discuss
- 8. What will be the output of the program?
class MyThread extends Thread { MyThread() { System.out.print(" MyThread"); } public void run() { System.out.print(" bar"); } public void run(String s) { System.out.println(" baz"); } } public class TestThreads { public static void main (String [] args) { Thread t = new MyThread() { public void run() { System.out.println(" foo"); } }; t.start(); } }
Options- A. foo
- B. MyThread foo
- C. MyThread bar
- D. foo bar Discuss
- 9. Which two statements are true?
- Deadlock will not occur if wait()/notify() is used
- A thread will resume execution as soon as its sleep duration expires.
- Synchronization can prevent two objects from being accessed by the same thread.
- The wait() method is overloaded to accept a duration.
- The notify() method is overloaded to accept a duration.
- Both wait() and notify() must be called from a synchronized context.
Options- A. 1 and 2
- B. 3 and 5
- C. 4 and 6
- D. 1 and 3 Discuss
- 10. The following block of code creates a Thread using a Runnable target:
Runnable target = new MyRunnable(); Thread myThread = new Thread(target);
Which of the following classes can be used to create the target, so that the preceding code compiles correctly?
Options- A. public class MyRunnable extends Runnable{public void run(){}}
- B. public class MyRunnable extends Object{public void run(){}}
- C. public class MyRunnable implements Runnable{public void run(){}}
- D. public class MyRunnable implements Runnable{void run(){}} Discuss
Threads problems
Search Results
Correct Answer: It print 12 12 12 12
Explanation:
The program will execute without any problems and print 12 12 12 12.
Correct Answer: Will print but not exactly in an order (e.g: 1 1 2 2 1 1 3 3...)
Explanation:
Both threads are operating on different sets of instance variables. If you modify the code of the run() method to print the thread name it will help to clarify the output:
Correct Answer: An exception occurs at runtime.
Explanation:
When the start() method is attempted a second time on a single Thread object, the method will throw an IllegalThreadStateException (you will not need to know this exception name for the exam). Even if the thread has finished running, it is still illegal to call start() again.
Correct Answer: Cannot be determined.
Explanation:
Can you guarantee the order in which threads are going to run? No you can't. So how do you know what the output will be? The output cannot be determined.
add this code after line 28:
try { Thread.sleep(5000); } catch(InterruptedException e) { }
and you have some chance of predicting the outcome.
Correct Answer: An exception occurs at runtime.
Explanation:
C is correct because the thread does not own the lock of the object it invokes wait() on. If the method were synchronized, the code would run without exception.
A, B are incorrect because the code compiles without errors.
D is incorrect because the exception is thrown before there is any output.
Correct Answer: The text "In run" followed by "Leaving run" will be displayed
Correct Answer: Will print but not be able to predict the Order
Explanation:
We cannot predict the order in which threads are going to run.
Correct Answer: MyThread foo
Explanation:
Option B is correct because in the first line of main we're constructing an instance of an anonymous inner class extending from MyThread. So the MyThread constructor runs and prints "MyThread". The next statement in main invokes start() on the new thread instance, which causes the overridden run() method (the run() method defined in the anonymous inner class) to be invoked, which prints "foo"
Correct Answer: 4 and 6
Explanation:
Statements (4) and (6) are correct. (4) is correct because the wait() method is overloaded to accept a wait duration in milliseconds. If the thread has not been notified by the time the wait duration has elapsed, then the thread will move back to runnable even without having been notified.
(6) is correct because wait()/notify()/notifyAll() must all be called from within a synchronized, context. A thread must own the lock on the object its invoking wait()/notify()/notifyAll() on.
(1) is incorrect because wait()/notify() will not prevent deadlock.
(2) is incorrect because a sleeping thread will return to runnable when it wakes up, but it might not necessarily resume execution right away. To resume executing, the newly awakened thread must still be moved from runnable to running by the scheduler.
(3) is incorrect because synchronization prevents two or more threads from accessing the same object.
(5) is incorrect because notify() is not overloaded to accept a duration.
Correct Answer: public class MyRunnable implements Runnable{public void run(){}}
Explanation:
The class correctly implements the Runnable interface with a legal public void run() method.
Option A is incorrect because interfaces are not extended; they are implemented.
Option B is incorrect because even though the class would compile and it has a valid public void run() method, it does not implement the Runnable interface, so the compiler would complain when creating a Thread with an instance of it.
Option D is incorrect because the run() method must be public.
Comments
There are no comments.Programming
Copyright ©CuriousTab. All rights reserved.