并发 hash map 删除复数值

Question

I have HashMap:

private final ConcurrentHashMap<String, List<Client>> clients;

And class:

public static class Client {
    private String name; // it is also the key of the map
    private String url;
}

From several threads, I call thread-safe method " removeElement " which has to remove one value from the list.

@Override
public CompletableFuture<Void> removeClient(Client client) {
    return CompletableFuture.runAsync(() ->
            clients.entrySet().removeIf(v ->
                    v.getValue().removeIf(
                            it -> client.url.equals(it.url))
            )
    );
}

But of course, it does not work. When I had got Method threw 'java.lang.UnsupportedOperationException' exception I resolved the issue like that:

@Override
public CompletableFuture<Void> removeClient(Client client) {
    return CompletableFuture.runAsync(() -> {
                List<Client> currentClients = new ArrayList<>(clients.get(client.getName()));
                currentClients.remove(client);
                if (currentClients.isEmpty()) {
                    clients.remove(client.getName());
                } else {
                    clients.put(client.getName(), currentClients);
                }
            }
    );
}

But it is not thread-safe. How can I achieve it here? Maybe there are more elegant ways to resolve it?

Answer 1

I think you could use ConcurrentHashMap::computeIfPresent in this case assuming that the same List instances are not put for the same keys:

CompletableFuture.runAsync(() -> {
    clients.computeIfPresent(client.getName(), (name, clients1) -> {
        List<Client> currentClients = new ArrayList<>(clients1);
        currentClients.remove(client);
        return currentClients.isEmpty() ? null : currentClients;
    });
});

Since computeIfPresent is performed atomically and we are using copy of the list inside remappingFunction - it should work.

As we can read in the docs:

If the value for the specified key is present, attempts to compute a new mapping given the key and its current mapped value. The entire method invocation is performed atomically . Some attempted update operations on this map by other threads may be blocked while computation is in progress, so the computation should be short and simple, and must not attempt to update any other mappings of this map.