Package io.opentelemetry.instrumentation.api.cache.weaklockfree

Class WeakConcurrentMap<K,​V>

  • All Implemented Interfaces:
    Iterable<Map.Entry<K,​V>>, Runnable
    Direct Known Subclasses:
    WeakConcurrentMap.WithInlinedExpunction
    public class WeakConcurrentMap<K,​V>
extends ReferenceQueue<K>
    A thread-safe map with weak keys. Entries are based on a key's system hash code and keys are considered equal only by reference equality. This class does not implement the Map interface because this implementation is incompatible with the map contract. While iterating over a map's entries, any key that has not passed iteration is referenced non-weakly.

    This class has been copied as is from https://github.com/raphw/weak-lock-free/blob/ad0e5e0c04d4a31f9485bf12b89afbc9d75473b3/src/main/java/com/blogspot/mydailyjava/weaklockfree/WeakConcurrentMap.java

    • Constructor Detail

      • WeakConcurrentMap

        public WeakConcurrentMap​(boolean cleanerThread)
        Parameters:
        cleanerThread - true if a thread should be started that removes stale entries.

      • WeakConcurrentMap

        public WeakConcurrentMap​(boolean cleanerThread,
                         boolean reuseKeys)
        Parameters:
        cleanerThread - true if a thread should be started that removes stale entries.
        reuseKeys - true if the lookup keys should be reused via a ThreadLocal. Note that setting this to true may result in class loader leaks. See isPersistentClassLoader(ClassLoader) for more details.

      • WeakConcurrentMap

        public WeakConcurrentMap​(boolean cleanerThread,
                         boolean reuseKeys,
                         ConcurrentMap<io.opentelemetry.instrumentation.api.cache.weaklockfree.AbstractWeakConcurrentMap.WeakKey<K>,​V> target)
        Parameters:
        cleanerThread - true if a thread should be started that removes stale entries.
        reuseKeys - true if the lookup keys should be reused via a ThreadLocal. Note that setting this to true may result in class loader leaks. See isPersistentClassLoader(ClassLoader) for more details.
        target - ConcurrentMap implementation that this class wraps.

    • Method Detail

      • getLookupKey

        protected io.opentelemetry.instrumentation.api.cache.weaklockfree.WeakConcurrentMap.LookupKey<K> getLookupKey​(K key)
        Override with care as it can cause lookup failures if done incorrectly. The result must have the same Object.hashCode() as the input and be equal to a weak reference of the key. When overriding this, also override resetLookupKey(L).

      • resetLookupKey

        protected void resetLookupKey​(io.opentelemetry.instrumentation.api.cache.weaklockfree.WeakConcurrentMap.LookupKey<K> lookupKey)
        Resets any reusable state in the lookup key.

      • getCleanerThread

        public Thread getCleanerThread()
        Returns:
        The cleaner thread or null if no such thread was set.

      • get

        public V get​(K key)
        Parameters:
        key - The key of the entry.
        Returns:
        The value of the entry or the default value if it did not exist.

      • getIfPresent

        public V getIfPresent​(K key)
        Parameters:
        key - The key of the entry.
        Returns:
        The value of the entry or null if it did not exist.

      • containsKey

        public boolean containsKey​(K key)
        Parameters:
        key - The key of the entry.
        Returns:
        true if the key already defines a value.

      • put

        public V put​(K key,
             V value)
        Parameters:
        key - The key of the entry.
        value - The value of the entry.
        Returns:
        The previous entry or null if it does not exist.

      • putIfAbsent

        public V putIfAbsent​(K key,
                     V value)
        Parameters:
        key - The key of the entry.
        value - The value of the entry.
        Returns:
        The previous entry or null if it does not exist.

      • putIfProbablyAbsent

        public V putIfProbablyAbsent​(K key,
                             V value)
        Parameters:
        key - The key of the entry.
        value - The value of the entry.
        Returns:
        The previous entry or null if it does not exist.

      • remove

        public V remove​(K key)
        Parameters:
        key - The key of the entry.
        Returns:
        The removed entry or null if it does not exist.

      • clear

        public void clear()
        Clears the entire map.

      • defaultValue

        protected V defaultValue​(K key)
        Creates a default value. There is no guarantee that the requested value will be set as a once it is created in case that another thread requests a value for a key concurrently.
        Parameters:
        key - The key for which to create a default value.
        Returns:
        The default value for a key without value or null for not defining a default value.

      • expungeStaleEntries

        public void expungeStaleEntries()
        Cleans all unused references.

      • approximateSize

        public int approximateSize()
        Returns the approximate size of this map where the returned number is at least as big as the actual number of entries.
        Returns:
        The minimum size of this map.

      • run

        public void run()
        Specified by:
        run in interface Runnable