O(1) reads and O(1) updates already rule out COW structures, in theory. COW structures are necessarily trees, and the best you can do is O(log N). In practice, though, especially as you expect to only keep about a 1000 mappings, you can use a tree with a very high branching factor (branching by 10 you get to leaf nodes in 3 hops, branching by 32 with 2 hops).

For only a 1000 mappings, constant factors will definitely be your most important concern.

Multithreaded and lockless spells STM to me. That means no blocking, but updates may fail and you need to retry.

But really, “best” can mean many different things. If absolute speed is what you want, your best bet may be to implement your own hash table tree. You can hand tune it for your particular application and key space, and possibly take some shortcuts that a generic data structure cannot.

If you want to use existing libraries, why not just try a handful and benchmark them all? I’d be interested to see the results :)

My requirements are:
- O(1) reads (in practice)
- O(1) changes to existing mappings.
- fast structural updates, especially before the moment the structure is shared
- low constant factors (this is maybe even more important than scalability; I may be wrong, but I don’t expect more than 1000 mappings to be present).
- multithreaded and lockless (well, memory barriers are needed, even if you don’t mention them)
Persistence is not a functional requirement, just an implementation detail of this idea.

Then, I was looking also at Java’s ConcurrentHashMap (which is just partially COW under the hood, but not fully) and Cliff’s Click NonblockingConcurrentHashMap (http://sourceforge.net/projects/high-scale-lib, http://www.azulsystems.com/events/javaone_2008/2008_CodingNonBlock.pdf).

What’s your suggestion?