如果达到内存大小限制，如何从地图中删除元素？

Question

我已经使用ConcurrentLinkedHashMap 实现了一个 LRU 缓存。在同一张地图中，如果我的地图达到如下所示的特定限制，我将清除事件。

我有一个等于 3.7 GB 的 MAX_SIZE 变量，一旦我的地图达到该限制，我就会从我的地图中清除事件。

下面是我的代码：

import java.util.concurrent.ConcurrentMap;
import com.googlecode.concurrentlinkedhashmap.ConcurrentLinkedHashMap;
import com.googlecode.concurrentlinkedhashmap.EvictionListener;

// does this really equal to 3.7 GB? can anyone explain this?
public static final int MAX_SIZE = 20000000; //equates to ~3.7GB with assumption that each event is 200 bytes AVG

public static EvictionListener<String, DataObject> listener = new EvictionListener<String, DataObject>() {
    public void onEviction(String key, DataObject value) {
        deleteEvents();
    }
};
public static final ConcurrentMap<String, DataObject> holder = new ConcurrentLinkedHashMap.Builder<String, DataObject>()
            .maximumWeightedCapacity(MAX_SIZE).listener(listener).build();

private static void deleteEvents() {
    int capacity = MAX_SIZE - (MAX_SIZE * (20 / 100));
    if (holder.size() >= capacity) {
        int numEventsToEvict = (MAX_SIZE * 20) / 100;
        int counter = 0;
        Iterator<String> iter = holder.keySet().iterator();
        while (iter.hasNext() && counter < numEventsToEvict) {
            String address = iter.next();
            holder.remove(address);
            System.out.println("Purging Elements: " +address);
            counter++;
        }
    }
}

// this method is called every 30 seconds from a single background thread 
// to send data to our queue
public void submit() {
    if (holder.isEmpty()) {
        return;
    }

    // some other code here

    int sizeOfMsg = 0;
    Iterator<String> iter = holder.keySet().iterator();
    int allowedBytes = MAX_ALLOWED_SIZE - ALLOWED_BUFFER;

    while (iter.hasNext() && sizeOfMsg < allowedBytes) {
        String key = iter.next();
        DataObject temp = holder.get(key);

        // some code here

        holder.remove(key);

        // some code here to send data to queue
    }
}   

// this holder map is used in below method to add the events into it.
// below method is being called from some other place.
public void addToHolderRequest(String key, DataObject stream) {
    holder.put(key, stream);
}

以下是我为此使用的 maven 依赖项：

<dependency>
    <groupId>com.googlecode.concurrentlinkedhashmap</groupId>
    <artifactId>concurrentlinkedhashmap-lru</artifactId>
    <version>1.4</version>
</dependency>

我不确定这是否是正确的方法？如果事件平均为 200 字节，这 MAX_SIZE 真的等于 3.7 GB 吗？有没有更好的方法来做到这一点？我还有一个后台线程，它每 30 秒调用一次 deleteEvents() 方法，同样的后台线程也调用 submit 方法从 holder 映射中提取数据并发送到队列。

所以想法是，在 addToHolderRequest 方法中将事件添加到 holder 映射，然后从后台每 30 秒调用一次 submit 方法，该方法将通过迭代此映射然后在提交方法完成后将数据发送到我们的队列，从同一后台线程调用deleteEvents() 方法，该方法将清除元素。我在生产中运行此代码，看起来它没有正确清除事件，并且我的持有者地图大小不断增长。我将最小/最大堆内存设置为 6GB。

Answer 1

1. 您可以使用“最常用于实现内存敏感缓存”(SoftReference) 的软引用来代替估计 JVM 中对象的大小并使用强引用来引用它们。例如CacheBuilder.softValues() 来自google/guava: Google Core Libraries for Java 6+：“为了响应内存需求，软引用对象将以全局最近最少使用的方式进行垃圾收集。”不过，我建议您先熟悉 CachesExplained · google/guava Wiki（特别是 Reference-based Eviction 部分）。
2. 作为使用软引用的一种调整，您还可以尝试here 中描述的“受害者缓存方法”，它使用“驱逐到 [a] 软缓存的普通缓存，并在可能的情况下恢复未命中的条目”。
3. 如果您确定要实际估​​计对象的大小，请查看Ehcache 及其Sizing Storage Tiers。它有 Built-In Sizing Computation and Enforcement 用于内存有限的缓存。