Java Programming - MCQ Practice Questions

The Runnable interface is the correct interface to implement for creating threads in Java. It has a single abstract method run().

Thread.sleep() pauses execution for a specified milliseconds, while yield() is a hint to the scheduler that the current thread is willing to yield its turn.

The interrupt() method is the proper way to stop a thread in Java. The stop() method is deprecated and dangerous.

The synchronized keyword provides mutual exclusion to ensure that only one thread can access a resource at a time, preventing race conditions.

The thread states are NEW, RUNNABLE, RUNNING, BLOCKED, WAITING, TIMED_WAITING, and TERMINATED. SLEEPING is not an official state.

Calling start() on an already started thread throws IllegalThreadStateException because a thread can only be started once.

The join() method causes the current thread to wait until the thread on which it is called completes its execution.

A race condition occurs when multiple threads access shared data and the final result depends on the order of execution, which is unpredictable.

A synchronized method locks the object, allowing only one thread to execute it at a time for that object instance.

notify() wakes up a single thread that is waiting on the object's monitor, while notifyAll() wakes up all threads waiting on that object.

The AtomicInteger class (and other Atomic classes) provides thread-safe operations without explicit synchronization using low-level atomic operations.

wait() must be called from within a synchronized context. Calling it without holding the lock throws IllegalMonitorStateException.

A daemon thread runs in the background and doesn't prevent the JVM from exiting. When all non-daemon threads finish, the JVM exits even if daemon threads are running.

Both extending Thread class and implementing Runnable interface are valid approaches to create threads in Java.

A deadlock occurs when two or more threads are blocked forever, waiting for each other to release resources they need.

The volatile keyword ensures that changes to a variable are immediately visible to all threads, providing memory visibility without the overhead of full synchronization.

When sleep() is called inside a synchronized block, the thread retains the lock on the object, preventing other threads from entering the synchronized section.

Semaphore is a synchronization utility that uses a counter to control access to a shared resource. Threads can acquire and release permits.

Thread pooling reuses a fixed set of threads instead of creating new ones for each task. ExecutorService provides convenient methods for thread pool management.

This is a classic circular wait scenario resulting in deadlock, where neither thread can proceed because each is waiting for a resource held by the other.