Question

I need to keep track of multiple values against unique keys i.e. 1(a,b) 2(c,d) etc…

The solution is accessed by multiple threads so effectively I have the following defined;

ConcurrentSkipListMap<key, ConcurrentSkipListSet<values>>

My question is does the removal of the key when the value set size is 0 need to be synchronized? I know that the two classes are “concurrent” and I’ve looked through the OpenJDK source code but I there would appear to be a window between one thread T1 checking that the Set is empty and removing the Map in remove(…) and another thread T2 calling add(…). Result being T1 removes last Set entry and removes the Map interleaved with T2 just adding a Set entry. Thus the Map and T2 Set entry are removed by T1 and data is lost.

Do I just “synchronize” the add() and remove() methods or is there a “better” way?

The Map is modified by multiple threads but only through two methods.

Code snippet as follows;

protected static class EndpointSet extends U4ConcurrentSkipListSet<U4Endpoint> {
    private static final long serialVersionUID = 1L;
    public EndpointSet() {
        super();
    }
}

protected static class IDToEndpoint extends U4ConcurrentSkipListMap<String, EndpointSet> {
    private static final long serialVersionUID = 1L;
    protected Boolean add(String id, U4Endpoint endpoint) {
        EndpointSet endpoints = get(id);
        if (endpoints == null) {
            endpoints = new EndpointSet();
            put(id, endpoints);
        }
        endpoints.add(endpoint);
        return true;
    }

    protected Boolean remove(String id, U4Endpoint endpoint) {
        EndpointSet endpoints = get(id);
        if (endpoints == null) {
            return false;
        } else {
            endpoints.remove(endpoint);
            if (endpoints.size() == 0) {
                remove(id);
            }
            return true;
        }
    }
}

Answer 1

As it is your code has data races. Examples of what could happen:

• a thread could add between if (endpoints.size() == 0) and remove(id); – you saw that
• in add, a thread could read a non null value in EndpointSet endpoints = get(id); and another thread could remove data from that set, remove the set from the map because the set is empty. The initial thread would then add a value to the set, which is not held in the map any longer => data gets lost too as it becomes unreachable.

The easiest way to solve your issue is to make both add and remove synchronized. But you then lose all the performance benefits of using a ConcurrentMap.

Alternatively, you could simply leave the empty sets in the map – unless you have memory constraints. You would still need some form of synchronization but it would be easier to optimise.

If contention (performance) is an issue, you could try a more fine grained locking strategy by synchronizing on the keys or values but it could be quite tricky (and locking on Strings is not such a good idea because of String pooling).

It seems that in all cases, you could use a non concurrent set as you will need to synchronize it externally yourself.