Discussion
Home ‣ Java Programming ‣ Threads Comments
- Question
Which statement is true?
Options- A. If only one thread is blocked in the wait method of an object, and another thread executes the modify on that same object, then the first thread immediately resumes execution.
- B. If a thread is blocked in the wait method of an object, and another thread executes the notify method on the same object, it is still possible that the first thread might never resume execution.
- C. If a thread is blocked in the wait method of an object, and another thread executes the notify method on the same object, then the first thread definitely resumes execution as a direct and sole consequence of the notify call.
- D. If two threads are blocked in the wait method of one object, and another thread executes the notify method on the same object, then the first thread that executed the wait call first definitely resumes execution as a direct and sole consequence of the notify call.
- Correct Answer
- If a thread is blocked in the wait method of an object, and another thread executes the notify method on the same object, it is still possible that the first thread might never resume execution.
ExplanationOption B is correct - The notify method only wakes the thread. It does not guarantee that the thread will run.Option A is incorrect - just because another thread activates the modify method in A this does not mean that the thread will automatically resume execution
Option C is incorrect - This is incorrect because as said in Answer B notify only wakes the thread but further to this once it is awake it goes back into the stack and awaits execution therefore it is not a "direct and sole consequence of the notify call"
Option D is incorrect - The notify method wakes one waiting thread up. If there are more than one sleeping threads then the choice as to which thread to wake is made by the machine rather than you therefore you cannot guarantee that the notify'ed thread will be the first waiting thread.
Threads problems
Search Results
- 1. 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
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.
- 2. 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
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.
- 3. 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
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"- 4. 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
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.- 5. 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
Correct Answer: The text "In run" followed by "Leaving run" will be displayed
- 6. Which statement is true?
Options- A. The notifyAll() method must be called from a synchronized context.
- B. To call wait(), an object must own the lock on the thread.
- C. The notify() method is defined in class java.lang.Thread.
- D. The notify() method causes a thread to immediately release its locks. Discuss
Correct Answer: The notifyAll() method must be called from a synchronized context.
Explanation:
Option A is correct because the notifyAll() method (along with wait() and notify()) must always be called from within a synchronized context.Option B is incorrect because to call wait(), the thread must own the lock on the object that wait() is being invoked on, not the other way around.
Option C is wrong because notify() is defined in java.lang.Object.
Option D is wrong because notify() will not cause a thread to release its locks. The thread can only release its locks by exiting the synchronized code.
- 7. Which statement is true?
Options- A. A static method cannot be synchronized.
- B. If a class has synchronized code, multiple threads can still access the nonsynchronized code.
- C. Variables can be protected from concurrent access problems by marking them with the synchronized keyword.
- D. When a thread sleeps, it releases its locks. Discuss
Correct Answer: If a class has synchronized code, multiple threads can still access the nonsynchronized code.
Explanation:
B is correct because multiple threads are allowed to enter nonsynchronized code, even within a class that has some synchronized methods.A is incorrect because static methods can be synchronized; they synchronize on the lock on the instance of class java.lang.Class that represents the class type.
C is incorrect because only methods?not variables?can be marked synchronized.
D is incorrect because a sleeping thread still maintains its locks.
- 8. Which two can be used to create a new Thread?
- Extend java.lang.Thread and override the run() method.
- Extend java.lang.Runnable and override the start() method.
- Implement java.lang.Thread and implement the run() method.
- Implement java.lang.Runnable and implement the run() method.
- Implement java.lang.Thread and implement the start() method.
Options- A. 1 and 2
- B. 2 and 3
- C. 1 and 4
- D. 3 and 4 Discuss
Correct Answer: 1 and 4
Explanation:
There are two ways of creating a thread; extend (sub-class) the Thread class and implement the Runnable interface. For both of these ways you must implement (override and not overload) the public void run() method.(1) is correct - Extending the Thread class and overriding its run method is a valid procedure.
(4) is correct - You must implement interfaces, and runnable is an interface and you must also include the run method.
(2) is wrong - Runnable is an interface which implements not Extends. Gives the error: (No interface expected here)
(3) is wrong - You cannot implement java.lang.Thread (This is a Class). (Implements Thread, gives the error: Interface expected). Implements expects an interface.
(5) is wrong - You cannot implement java.lang.Thread (This is a class). You Extend classes, and Implement interfaces. (Implements Thread, gives the error: Interface expected)
- 9. Which of the following statements is true?
Options- A. In an assert statement, the expression after the colon ( : ) can be any Java expression.
- B. If a switch block has no default, adding an assert default is considered appropriate.
- C. In an assert statement, if the expression after the colon ( : ) does not have a value, the assert's error message will be empty.
- D. It is appropriate to handle assertion failures using a catch clause. Discuss
Correct Answer: If a switch block has no default, adding an assert default is considered appropriate.
Explanation:
Adding an assertion statement to a switch statement that previously had no default case is considered an excellent use of the assert mechanism.Option A is incorrect because only Java expressions that return a value can be used. For instance, a method that returns void is illegal.
Option C is incorrect because the expression after the colon must have a value.
Option D is incorrect because assertions throw errors and not exceptions, and assertion errors do cause program termination and should not be handled.
- 10. Which of the following statements is true?
Options- A. If assertions are compiled into a source file, and if no flags are included at runtime, assertions will execute by default.
- B. As of Java version 1.4, assertion statements are compiled by default.
- C. With the proper use of runtime arguments, it is possible to instruct the VM to disable assertions for a certain class, and to enable assertions for a certain package, at the same time.
- D. When evaluating command-line arguments, the VM gives -ea flags precedence over -da flags. Discuss
Correct Answer: With the proper use of runtime arguments, it is possible to instruct the VM to disable assertions for a certain class, and to enable assertions for a certain package, at the same time.
Explanation:
Option C is true because multiple VM flags can be used on a single invocation of a Java program.Option A is incorrect because at runtime assertions are ignored by default.
Option B is incorrect because as of Java 1.4 you must add the argument -source 1.4 to the command line if you want the compiler to compile assertion statements.
Option D is incorrect because the VM evaluates all assertion flags left to right.
Comments
There are no comments.
Programming
Copyright ©CuriousTab. All rights reserved.
- 1. The following block of code creates a Thread using a Runnable target: