Scaffeine: how to set different expiration time for default value

Question

Scala application use case:

We have a Scala based that module reads the data from global cache (Redis) and save the same into local cache(Scaffeine). As we want this data to be refreshed asynchronously, we are using LoadingCache with refreshAfterWrite duration set to refresh window of 2.second.

Question:

We need to set different expiry time while setting values in local cache based on if key present in the redis (global cache) or not.

e.g. If the key is not present in the global cache, we want to save the same key in local cache with default value and refresh window set to 5.minutes. If key is present in the global cache, we want to store the same in local cache with actual value and refresh window set to 30.minute.

Sample code

object LocalCache extends App {

  // data being stored in the cache
  class DataObject(data: String) {
    override def toString: String = {
      "[ 'data': '" + this.data + "' ]"
    }
  }

  // loader helper
  private def loaderHelper(key: Int): Future[DataObject] = { 
    // this method will replace to read the data from Redis Cache
    // for now, returns different values per key

    if (key == 1) Future.successful(new DataObject("LOADER_HELPER_1"))
    else if (key == 2) Future.successful(new DataObject("LOADER_HELPER_2"))
    else Future.successful(new DataObject("LOADER_HELPER"))
  }

  // async loader
  private def loader(key: Int): DataObject = {
      Try {
        Await.result(loaderHelper(key), 1.seconds)
      } match {
        case Success(result) =>
          result
        case Failure(exception: Exception) =>
          val temp: DataObject = new DataObject("LOADER")
          temp
      }
  }

  // initCache
  private def initCache(maximumSize: Int): LoadingCache[Int, DataObject] =
    Scaffeine()
      .recordStats()
      .expireAfterWrite(2.second)
      .maximumSize(maximumSize)
      .build(loader)

  // operations on the cache.
  val cache: LoadingCache[Int, DataObject] = initCache(maximumSize = 500)
  cache.put(1, new DataObject("foo"))
  cache.put(2, new DataObject("hoo"))

  println("sleeping for 3 sec\n")
  Thread.sleep(3000)
  println(cache.getIfPresent(1).toString)
  println(cache.getIfPresent(2).toString)
  println(cache.get(3).toString)

  println("sleeping for 10 sec\n")
  Thread.sleep(10000)
  println("waking up from 10 sec sleep")

  println(cache.get(1).toString)
  println(cache.get(2).toString)
  println(cache.get(3).toString)

  println("\nCache Stats: "+ cache.stats())
}

I see lots of custom.policy that can be used to overwrite the expiryAfter policies (expiryAfterWrite/Update/Access) but nothing can be found for refreshAterWrite policies which refreshes the data asynchronously. Any help will be appreciable.

P.S. I'm very newbie to work on Scala and also explore the Scaffeine.

Answer 1

Unfortunately variable refresh is not supported yet. There is an open issue to provide that feature.

At the moment expiration can be custom per entry, but automatic refresh is fixed. A manual refresh may be triggered by LoadingCache.refresh(key), if you want to manage it yourself. For example, you could periodically iterate over the entries (via the asMap() view) and refresh manually based on a custom criteria.

The AsyncLoadingCache could be useful instead of blocking on a future within your cache loader. The cache will return the in-flight future, won't make it expirable until the value materializes, and will remove it if it fails. Note that the synchronous() view is very useful for async caches to access more operations.

From testing, you might find Guava's fake ticker useful to simulate time.