OCP Java Concurrency Questions and Answers

Question 1

An `ExecutorService` is actively running tasks. A separate thread calls the `shutdown()` method on the service. Immediately after, another attempt is made to submit a new task using the `submit()` method. What will be the result of this second submission attempt?

Accepted Answer

The submission will be rejected, and a `RejectedExecutionException` will be thrown.

Answer

The `ExecutorService.shutdown()` method initiates an orderly shutdown where previously submitted tasks are executed, but no new tasks will be accepted. Any attempt to submit a new task to the service after `shutdown()` has been called will result in a `RejectedExecutionException`.

Question 2

Which of the following statements most accurately describes a primary difference between `java.util.concurrent.CyclicBarrier` and `java.util.concurrent.CountDownLatch`?

Accepted Answer

`CountDownLatch` is designed for a single use, whereas `CyclicBarrier` can be reset and reused after all waiting threads are released.

Answer

The most significant difference is that a `CyclicBarrier` is reusable. After the barrier is tripped (all parties have arrived), it can be reset to its initial state, either automatically or by calling `reset()`, for another round of coordination. A `CountDownLatch` is a one-time-use synchronizer; once its count reaches zero, it cannot be reset.

Question 3

A developer is creating a high-performance, thread-safe counter for a heavily used application. Which approach is generally preferred over using a `synchronized` method for a simple atomic increment operation?

Accepted Answer

Using the `incrementAndGet()` method of `java.util.concurrent.atomic.AtomicInteger`.

Answer

`AtomicInteger` is specifically designed for this purpose. It uses low-level, non-blocking hardware instructions like Compare-And-Swap (CAS) to perform atomic operations. Under low to moderate contention, this is typically more performant than using a `synchronized` block or a `ReentrantLock`, which involves thread blocking and context switching overhead. A `volatile` variable only guarantees visibility, not atomicity for a read-modify-write operation like incrementing.

Question 4

In a multi-threaded application, you need a `Map` that will be read from very frequently by many threads but written to only occasionally. High throughput for read operations is critical. Which of the following is the most suitable thread-safe `Map` implementation for this scenario?

Accepted Answer

`java.util.concurrent.ConcurrentHashMap`

Answer

`ConcurrentHashMap` is the ideal choice. It is designed for high concurrency and scalability. It achieves this by using a fine-grained locking mechanism (e.g., locking only specific 'buckets' or segments of the map) which allows multiple read operations to occur concurrently without any blocking. In contrast, `Collections.synchronizedMap()` and the legacy `Hashtable` use a single lock for the entire map, meaning only one thread can access it at a time for any operation, creating a bottleneck in read-heavy scenarios.

Question 5

What are the key differences in the method signatures of `java.lang.Runnable` and `java.util.concurrent.Callable`?

Accepted Answer

The `run()` method of `Runnable` cannot return a value, while the `call()` method of `Callable` can.

Answer

The `run()` method in the `Runnable` interface has a `void` return type. In contrast, the `call()` method in the `Callable<V>` interface returns a generic type `V`, allowing the asynchronous task to produce a result. Additionally, the `call()` method is declared to throw `Exception`, permitting checked exceptions to be propagated, which is not possible with `run()`.

(OCP) Oracle Certified Professional Practice Test

(OCP) Oracle Certified Professional Practice Test

OCP Java Concurrency Questions and Answers