Java containsKey() on ConcurrentHashMap returns false for a UUID key that present in the map

Question

I am using an object of type

Map<Long, Map<UUID, OperationEntry>> stepOperations = new ConcurrentHashMap<>(); 

to control the execution of some operations. I have a Kafka message handler method that, upon receiving a message about a status change of an operation, needs to find and update the state of a record in stepOperations map based on the passed UUID.

UUID class is not overriden (standatd java.util.UUID).

What could be the reason for getting an unexpected result from the containsKey method if the key "3102869c-7653-4fb7-ad47-a629b5cbac90", as clearly seen in the screenshot, is present in the map?

Here is the problematic part of the code:

   private OperationEntry getOperationLogEntry(UUID requestId) {
        return stepOperations.values().stream()
            .filter(value -> value.containsKey(requestId))
            .map(value -> value.get(requestId))
            .findFirst()
            .orElse(null);
    }

The ConcurrentHashMap class is used due to its guaranted support for multithreaded processing. The incoming Kafka messages are processed by a thread pool consisting of 16 threads.

Could the presence of a inner map be a potential issue here?

Simple test such as

        Map<UUID, String> testMap = new java.util.concurrent.ConcurrentHashMap<>();
        UUID key = UUID.randomUUID();
        testMap.put(key, "testValue");
        if (testMap.containsKey(key)) {
            System.out.println(testMap.get(key));
        }

works as it's expected to be

Answer 1

In the debugger, we can see that value variable in an HashMap. Not a ConcurrentHashMap:

When you work with multi levels of map, you should use computeIfAbsent.

From your code, you should probably:

• have stepOperations be ConcurrentMap<Long, ConcurrentMap<UUID, Whatever>> to make sure the two levels are good.
• use computeIfAbsent as in stepOperations.computeIfAbsent(key, ignored -> new ConcurrentHashMap<>())
• ensure that the map itself is not accessible externally (where the map could be polluted).

To add a new step:

stepOperations.computeIfAbsent(opId,  ignored -> new ConcurrentHashMap<>()))
              .put(opUUID, opWhatever)

Finally, you could probably rewrite your code:

stepOperations
   .values()
   .stream()
   .filter(value -> value.containsKey(operationRunState.requestId))
   .map(value -> value.get(operationRunState.requestId))
   .findFirst()

Do that instead:

var id = operationRunState.requestId;
stepOperations
   .values()
   .stream().map(value -> value.get(id))
   .filter(Objects::nonNull)
   .findFirst();

Two points:

• use a local variable id to ensure you use the same id
• ConcurrentHashMap forbids key and value from being null: the containsKey is useless here.

Answer 2

thank you for your responses. Indeed, replacing

private final Map<Long, Map<UUID, OperationEntry>> stepOperations = new ConcurrentHashMap<>();

with

private final ConcurrentMap<Long, ConcurrentMap<UUID, OperationEntry>> stepOperations = new ConcurrentHashMap<>();

had helped. In this case, the inner map is also must be concurrent.