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 task will be accepted and placed in the queue to be executed after the currently running tasks complete.

Answer

The `submit()` call will block indefinitely until the `ExecutorService` has fully terminated.

Answer

The new task will be executed immediately by the calling thread.

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

`CyclicBarrier` is limited to coordinating exactly two threads, while `CountDownLatch` can coordinate any number of threads.

Answer

Threads wait on a `CyclicBarrier` by calling `countDown()`, and on a `CountDownLatch` by calling `await()`.

Answer

Only `CountDownLatch` allows a timeout to be specified when waiting.

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

Declaring the primitive integer counter as `volatile`.

Answer

Using a `ReentrantLock` to protect the increment operation.

Answer

Wrapping the integer in a `Collections.synchronizedMap`.

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

A `HashMap` wrapped with `Collections.synchronizedMap()`

Answer

`java.util.Hashtable`

Answer

A `TreeMap` protected by a `ReadWriteLock`

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 `call()` method of `Callable` cannot throw checked exceptions, while the `run()` method of `Runnable` can.

Answer

`Runnable`'s `run()` method accepts an argument, while `Callable`'s `call()` method does not.

Answer

`Runnable` has a `start()` method, whereas `Callable` has a `call()` method.

Question 6

A shared instance of the following class is accessed by multiple threads. Which concurrency issue is most likely to occur?

```java
public class TextBuilder {
    private StringBuilder content = new StringBuilder();

public void appendText(String text) {
        this.content.append(text);
    }

public String toString() {
        return content.toString();
    }
}
```

Accepted Answer

A race condition leading to corrupted or lost data within the `StringBuilder`.

Answer

A `NullPointerException` when calling `toString()`.

Answer

A deadlock if two threads call `appendText()` simultaneously.

Answer

A `ConcurrentModificationException` during the `append()` operation.