org.infinispan.client.hotrod.near.LinkedMapNearCache Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of infinispan-remote

Infinispan Remote Client All-in-One module

There is a newer version: 9.1.7.Final

package org.infinispan.client.hotrod.near;

import org.infinispan.client.hotrod.VersionedValue;
import org.infinispan.client.hotrod.configuration.NearCacheConfiguration;

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * {@link java.util.LinkedHashMap} based near cache implementation.
 * Concurrent access is controlled by a reentrant RW lock.
 */
public class LinkedMapNearCache implements NearCache {

   private final LinkedHashMap> cache;

   private final ReadWriteLock rwlock = new ReentrantReadWriteLock();

   protected LinkedMapNearCache(LinkedHashMap> cache) {
      this.cache = cache;
   }

   @Override
   public void put(K key, VersionedValue value) {
      Lock lock = rwlock.writeLock();
      try {
         lock.lock();
         cache.put(key, value);
      } finally {
         lock.unlock();
      }
   }

   @Override
   public void putIfAbsent(K key, VersionedValue value) {
      Lock lock = rwlock.writeLock();
      try {
         lock.lock();
         VersionedValue current = cache.get(key);
         if (current == null)
            cache.put(key, value);
      } finally {
         lock.unlock();
      }
   }

   @Override
   public void remove(K key) {
      Lock lock = rwlock.writeLock();
      try {
         lock.lock();
         cache.remove(key);
      } finally {
         lock.unlock();
      }
   }

   @Override
   public VersionedValue get(K key) {
      Lock lock = rwlock.readLock();
      try {
         lock.lock();
         return cache.get(key);
      } finally {
         lock.unlock();
      }
   }

   @Override
   public void clear() {
      Lock lock = rwlock.writeLock();
      try {
         lock.lock();
         cache.clear();
      } finally {
         lock.unlock();
      }
   }

   public static  NearCache create(final NearCacheConfiguration config) {
      return new LinkedMapNearCache(
            new LinkedHashMap>(1 << 4, 0.75f, true) {
         @Override
         protected boolean removeEldestEntry(Map.Entry eldest) {
            return size() > config.maxEntries();
         }
      });
   }

}