Threads - Pointing out the correct statements Questions and Answers

51.

Starting a thread, joining it, then starting it again - which of the following is true?

Thread t = new Thread(() -> System.out.println("working"));
t.start();
t.join();
t.start();

A.The second start() is ignored and the program prints the message once.
B.The code fails to compile.
C.An IllegalThreadStateException is thrown on the second start().
D.The run body executes twice, once per call to start().

Answer: C

A thread may not be started twice, and cannot be restarted even after run() has finished. The first call succeeds and prints; the second throws IllegalThreadStateException in the main thread. Note the failure is at runtime, not compile time: nothing in the type system tracks whether start() has already happened.

Discuss in Forum

52.

Which of these statements about invoking run() on a thread that is never started is correct?

Thread t = new Thread(() -> System.out.println(
        Thread.currentThread().getName()));
t.run();

A.Two threads exist; the output is produced by the new thread.
B.Two threads exist.
C.The code does not compile.
D.Only one thread exists.

Answer: D

Invoking run() directly is an ordinary method call, so nothing is scheduled and the body executes on whichever thread made the call, here main. The Thread object is created but never started, so it stays in the NEW state for the whole program. Replacing run() with start() is what makes it concurrent.

Discuss in Forum

53.

Which one of the following statements about calling wait() outside any synchronized region is true?

Object lock = new Object();
lock.wait();

A.An IllegalMonitorStateException is thrown.
B.The call blocks for ever.
C.The call returns immediately.
D.The code does not compile.

Answer: A

wait, notify and notifyAll may only be called by a thread that owns the object's monitor, and this call sits outside any synchronized region. The result is IllegalMonitorStateException at runtime rather than a hang. Wrapping the call in synchronized (lock) is what makes it legal.

Discuss in Forum

54.

Consider a notify that arrives before the matching wait. Which statement is correct?

// thread A                     // thread B
synchronized (lock) {           synchronized (lock) {
    lock.notify();                  lock.wait();
}                               }

A.An IllegalMonitorStateException is thrown by the wait() call.
B.The waiting thread may never wake.
C.The waiting thread wakes immediately.
D.The waiting thread wakes after a default timeout of one second.

Answer: B

A monitor keeps no record of notifications. If notify() runs before the other thread reaches wait(), the signal is simply discarded and the later wait blocks with nothing left to wake it. This is the lost-wakeup problem, and it is why the condition is tested inside a synchronized region before waiting at all.

Discuss in Forum

55.

A synchronized method that sleeps while holding its lock - which of the following is true?

class Store
{
    synchronized void hold() throws InterruptedException
    {
        Thread.sleep(1000);
    }

    synchronized void other() { }
}

A.The sleep releases the monitor only after half the requested time has elapsed.
B.An IllegalMonitorStateException is thrown.
C.Nothing else can enter either synchronized method while the sleep is in progress.
D.The sleep releases the monitor.

Answer: C

sleep does not lose ownership of any monitor, so the lock on the instance is held for the whole second and both synchronized methods stay closed to other threads. Using wait(1000) instead would release the monitor and let the other method proceed, which is the practical difference between the two.

Discuss in Forum

56.

Which of these statements about the priority constants on Thread is correct?

A.MIN_PRIORITY is 0, NORM_PRIORITY is 5 and MAX_PRIORITY is 9.
B.MIN_PRIORITY is 1, NORM_PRIORITY is 10 and MAX_PRIORITY is 100.
C.The constants vary by platform and are not fixed by the class.
D.MIN_PRIORITY is 1, NORM_PRIORITY is 5 and MAX_PRIORITY is 10.

Answer: D

Thread defines these three as 1, 5 and 10, and they are fixed constants rather than platform values. A value outside 1 to 10 causes IllegalArgumentException. What is platform-dependent is the effect of a priority, not the number itself.

Discuss in Forum

57.

Which one of the following statements about the default name of an unnamed thread is true?

A.An unnamed thread is given a default name of the form Thread-0, Thread-1 and so on.
B.An unnamed thread has a null name until setName() is called.
C.An unnamed thread takes the name of the class whose run() it executes.
D.An unnamed thread takes the name of the thread that created it.

Answer: A

The constructors that take no name generate one by appending a counter, giving Thread-0 for the first. The name is only a label used in traces and dumps, so it need not be unique, but naming threads meaningfully makes a thread dump far easier to read.

Discuss in Forum

58.

Consider what wait(1000) tells you when it returns. Which statement is correct?

A.wait(1000) always waits the full interval, even after a notification arrives.
B.wait(1000) returning does not by itself reveal whether it timed out or was notified.
C.wait(1000) returns true when notified and false when it times out.
D.wait(1000) throws TimeoutException when the interval elapses without a notification.

Answer: B

wait returns void, so on return the thread knows only that it is running again, whether from a notify, a timeout, an interrupt or a spurious wakeup. That is precisely why the condition must be re-tested in a loop; the return itself carries no information.

Discuss in Forum

59.

AtomicInteger.incrementAndGet() - which of the following is true?

A.AtomicInteger.incrementAndGet() is equivalent to declaring an int volatile and using ++.
B.AtomicInteger.incrementAndGet() locks the object.
C.AtomicInteger.incrementAndGet() performs the whole increment as one atomic operation.
D.AtomicInteger.incrementAndGet() is atomic only inside a synchronized block.

Answer: C

The atomic classes exist because volatile alone cannot make a read-modify-write safe. incrementAndGet performs the whole update as one indivisible step, typically with a compare-and-swap instruction rather than a lock, so no update is lost and no monitor is acquired.

Discuss in Forum

60.

Which of these statements about double-checked locking is correct?

A.Double-checked locking is correct as written.
B.Double-checked locking is never correct in Java.
C.Double-checked locking requires the field to be final rather than volatile.
D.Double-checked locking is only correct if the field is declared volatile.

Answer: D

Without volatile, another thread can observe a non-null reference before the constructor's writes are visible, and use a partly built object. Declaring the field volatile supplies the happens-before edge that makes the idiom sound. The second check inside the lock does nothing about visibility.

Discuss in Forum

Loading…

Topics

No topic!

Other Subjects

Tags: Threads - Pointing out the correct statements Questions and Answers || Threads - Pointing out the correct statements MCQ Questions and Answers || Threads - Pointing out the correct statements GK Questions and Answers || Threads - Pointing out the correct statements GK MCQ Questions || Threads - Pointing out the correct statements Multiple Choice Questions and Answers || Threads - Pointing out the correct statements GK || GK on Threads - Pointing out the correct statements || Java Programming Questions and Answers || Java Programming MCQ Questions and Answers || Java Programming GK Questions and Answers || GK on Java Programming

Threads - Pointing out the correct statements Questions and Answers

Topics

Other Subjects

About Us

Stay informed about all important Dates & Notifications