How to convert ConcurrentLinkedHashMap to Caffeine

[nagraj321]

We previously utilized ConcurrentLinkedHashMap in our project, part of ActiveMQ 5.14.X. As we are upgrading to ActiveMQ 5.16.7, we've observed that ConcurrentLinkedHashMap has been replaced with Caffeine. Consequently, we seek guidance on adapting our existing code to support Caffeine. The following is a snippet of the original code:

public class TestResultCache implements EvictionListener<String, TestBucket> {
    protected ConcurrentLinkedHashMap<String, TestBucket> bucketMap;

    bucketMap = new ConcurrentLinkedHashMap
                .Builder<String, SessionBucket>()
                .maximumWeightedCapacity(capacity)
                .listener(this)
                .build();
}

To migrate to Caffeine, we can make the necessary adjustments:

[ben-manes]

You may want to review the migration guide. I would probably rewrite your snippet as,

public class TestResultCache {
  private final Cache<String, TestBucket> buckets;

  public TestResultCache() {
    buckets = Caffeine.newBuilder()
        .removalListener((String key, TestBucket value, RemovalCause cause) -> {
          if (cause.wasEvicted()) {
            // ...
          }
        })
        .maximumSize(capacity)
        .build();
  }
}

[nagraj321]

Thanks I have made the changes however i see an issue with the capacity.

bucketMap = Caffeine.newBuilder()
                .maximumSize(100)
                .removalListener(this)
                .build();

int cacheSize = 100;
int testSize = 10;

// Test the maintenance of the maximum capacity
for (int i = 0; i < cacheSize; i++) {
    String testString = "test "+ i;
    // Populate the cache up to its maximum capacity
    TestResultCache.put(testString, KEY.TEST_NONE.getKeyName(), testString, testLifespan);
}

// Verify that the cache maintains the expected maximum capacity
int nObserved = TestResultCache.getBucketCount();
int nExpected = cacheSize;
Assert.assertTrue(sizeInfo("0", nObserved, nExpected), nObserved == nExpected);

// Add entries beyond the cache capacity
for (int i = cacheSize; i < (cacheSize + testSize); i++) {
    String testString = formatTestString(i);
    // Attempt to add entries beyond the cache's maximum capacity
    TestResultCache.put(testString, KEY.TEST_NONE.getKeyName(), testString, testLifespan);
}

// Verify that the cache size remains within the specified maximum capacity
nObserved = TestResultCache.getBucketCount();
// The observed count should still be equal to the initial cache size
nExpected = cacheSize;
Assert.assertTrue(sizeInfo("0", nObserved, nExpected), nObserved == nExpected);

Here we are expecting 100 but we observed 110. Any idea what could be the reason?

[ben-manes]

Oh right. A difference is that Caffeine defers work to an Executor, which by default is ForkJoinPool.commonPool(), whereas ConcurrentLinkedHashMap performs that on the calling thread. This change is because while the cache's own work is very fast, the user's might be very slow and that shouldn't penalize user-facing latencies (e.g. an expensive eviction listener).

The simplest approach is to change the cache configuration to perform the work directly, Caffeine.executor(Runnable::run). That will pass your test as it handles eviction immediately on the test thread. The alternative is to either call Cache.cleanUp() prior to the assertion or use an asynchronous assertion like Awaitility.