Attempt to call close() on evicted cache values

utils/src/main/java/software/amazon/awssdk/utils/cache/lru/LruCache.java

@@ -21,6 +21,7 @@
 import java.util.function.Function;
 import software.amazon.awssdk.annotations.SdkProtectedApi;
 import software.amazon.awssdk.annotations.ThreadSafe;
+import software.amazon.awssdk.utils.Logger;
 import software.amazon.awssdk.utils.Validate;
 
 /**
@@ -40,6 +41,8 @@
 @ThreadSafe
 public final class LruCache<K, V>  {
 
+    private static final Logger log = Logger.loggerFor(LruCache.class);
+
     private static final int DEFAULT_SIZE = 100;
 
     private final Map<K, CacheEntry<K, V>> cache;
@@ -146,10 +149,21 @@ private void addToQueue(CacheEntry<K, V> entry) {
      */
     private void evict() {
         leastRecentlyUsed.isEvicted(true);
+        closeEvictedResourcesIfPossible(leastRecentlyUsed.value);
         cache.remove(leastRecentlyUsed.key());
         removeFromQueue(leastRecentlyUsed);
     }
 
+    private void closeEvictedResourcesIfPossible(V value) {
+        if (value instanceof AutoCloseable) {
+            try {
+                ((AutoCloseable) value).close();
+            } catch (Exception e) {
+                log.warn(() -> "Attempted to close instance that was evicted by cache, but got exception: " + e.getMessage());
+            }
+        }
+    }
+
     public int size() {
         return cache.size();
     }

utils/src/test/java/software/amazon/awssdk/utils/cache/lru/LruCacheTest.java

@@ -21,6 +21,7 @@
 import static software.amazon.awssdk.utils.FunctionalUtils.invokeSafely;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
@@ -113,6 +114,37 @@ void when_cacheFillsUp_ValuesAreEvictedFromCache() {
         verify(simpleValueSupplier, times(1)).apply(simpleTestKeys.get(4));
     }
 
+    @Test
+    void when_closeableValuesAreEvicted_CloseMethodIsCalled() {
+        int cacheSize = 3;
+        int evictNum = 2;
+        LruCache<Integer, CloseableClass> cache = LruCache.builder(CloseableClass::new)
+                                                          .maxSize(cacheSize)
+                                                          .build();
+        CloseableClass.reset();
+        for (int i = 0; i < cacheSize + evictNum; i++) {
+            cache.get(i);
+        }
+        assertThat(CloseableClass.evictedItems()).isNotEmpty();
+        assertThat(CloseableClass.evictedItems()).hasSize(evictNum);
+        assertThat(CloseableClass.evictedItems().get(0)).isEqualTo(0);
+        assertThat(CloseableClass.evictedItems().get(1)).isEqualTo(1);
+    }
+
+    @Test
+    void when_closeableValuesAreEvicted_NoExceptionsAreThrownIfCloseFails() {
+        int cacheSize = 3;
+        int evictNum = 2;
+        LruCache<Integer, FaultyCloseableClass> cache = LruCache.builder(FaultyCloseableClass::new)
+                                                                .maxSize(cacheSize)
+                                                                .build();
+        CloseableClass.reset();
+        for (int i = 0; i < cacheSize + evictNum; i++) {
+            cache.get(i);
+        }
+        assertThat(CloseableClass.evictedItems()).isEmpty();
+    }
+
     @Test
     void when_mostRecentValueIsHit_ValuesAreReorderedCorrectly() {
         LruCache<Integer, String> cache = simpleCache.get();
@@ -257,4 +289,42 @@ public String apply(Integer key) {
             return value;
         }
     }
+
+    private static class CloseableClass implements AutoCloseable {
+
+        private static List<Integer> evictedList = new ArrayList<>();
+
+        private final Integer key;
+        CloseableClass(Integer key) {
+            this.key = key;
+        }
+        public Integer get() throws Exception {
+            return key;
+        }
+
+        public static void reset() {
+            evictedList = new ArrayList<>();
+        }
+
+        public static List<Integer> evictedItems() {
+            return Collections.unmodifiableList(evictedList);
+        }
+
+        @Override
+        public void close() {
+            evictedList.add(key);
+        }
+    }
+
+    private static class FaultyCloseableClass extends CloseableClass {
+
+        FaultyCloseableClass(Integer key) {
+            super(key);
+        }
+
+        @Override
+        public void close() {
+            throw new RuntimeException("Could not close resources!");
+        }
+    }
 }