I can imagine only three major variations of cache: A, B and C.

My point is that we either

* have synchronization on cache read (A) *

or

* maintain per-thread local cache replicas (B, C) *

variants B and C look quite wasteful in term of memory
(or the don’t, hmm… Adrian?)

And the question is what does intern do?
Perhaps A?

CacheA
{
Map m_global = new HashMap();

get( key )
{
synchronized( m_global )
{
return m_global.get( key );
}
}

put( key, value )
{
synchronized( m_global )
{
m_global.put( key, value );]
}
}
}

CacheB
{
ThreadLocal m_threadLocal = new ThreadLocal();
Map m_global = new HashMap();

get( key )
{
Map localMap = m_local.get();
if ( localMap != null )
{
Object found = localMap.get( key );
if ( found != null )
{
return found;
}
}

synchronized( m_global )
{
Object found = m_global.get( key );
if ( found != null )
{
if ( localMap == null )
{
localMap = new HashMap();
m_local.put( localMap );
}

localMap.put( key, found );
}
return found;
}
}

put( key, value )
{
synchronized( m_global )
{
m_blobal.put( key, value );
}
Map localMap = m_local.get();
if ( localMap == null )
{
localMap = new HashMap();
m_local.set( localMap );
}
localMap.put( key, value );
}
}

CacheC
{
ThreadLocal m_threadLocal = new ThreadLocal();
Map m_global = new HashMap();

get( key )
{
Map localMap = m_local.get();
if ( localMap != null )
{
Object found = localMap.get( key );
if ( found != null )
{
return found;
}
}

synchronized( m_global )
{
if ( localMap == m_global )
{
return;
}

m_local.set( m_global );
return m_global.get( key ):
}
}

put( key, value )
{
synchronized( m_global )
{
m_global = m_global.clone();
m_global.put( key, value );
m_local.set( m_global );
}
}
}