Question

I have a concurrent scenario where I have to write a lot to a sorted datastructure.

I thought about using ConcurrentSkipListMap for this reason. My definition is something like this: ConcurrentSkipListMap<K, List<V>>, which of course makes it quite difficult to manage insertions of the List<V> when the first element is inserted.

I.e.:

List<V> list = map.get(k);
if (list == null) {
    list = new LinkedList<V>();
    map.put(list);
}
list.add(v);

Of course this is not atomic. Using the class putIfAbsent() method would make it quite awkward and inefficient:

List<V> newElement = new LinkedList<V>();
List<V> previous = map.putIfAbsent(k, newElement);
if (previous != null) {
    previous.add(v);
} else {
    newElement.add(v);
}

One way is of course to create my own lock and protect a normal TreeMap, but as I have a real high write rate on this object, I’d prefer something designed specifically for it. Something like collections.defaultdict of python would be perfect, of course.

Answer 1

A couple things.

First: The most effecient way to handle your the put-if-absent case is to do a pseudo double check

public void add(Object key, Object val) {
    List list = map.get(key);
    if (list == null) {
        list = new LinkedList();
        List temp = map.putIfAbsent(list);
        if (temp != null)
            list = temp;
    }
    list.add(val);
}

That is as effecient as you can get for the put-if-absent case.

Second: You still have a concurrency issue here with adding to the list. You may want to wrap the LinkedList in Collections.synchronizedList() before putting to the map.

public void add(Object key, Object val) {
        List list = map.get(key);
        if (list == null) {
            list = Collections.synchronizedList(new LinkedList());
            List temp = map.putIfAbsent(list);
            if (temp != null)
                list = temp;
        }
        list.add(val);
    }