Question

我需要在指定的时间范围内跟踪某些事件，并在事件数量达到某个数字时执行操作。更详细地说，我连接到外部服务并提交已确认状态等于CONF或FAIL的请求。我需要能够监视响应，以检测在给定的时间范围内是否出现异常数量的失败，例如＆gt; 3在最后5秒内失败，因此我可以检查错误并采取相应措施。我也可以连续检查3次失败，但我更喜欢基于时间的方法。

我在阅读此post后一直在测试Guava的CacheLoader但是当缓存中的条目（我只存储FAIL事件）似乎按预期到期时，调用size()（确定失败次数）还包括过期的条目。如果我没有误解事情，这似乎是根据documentation的工作原理？有没有办法从缓存中获取“活动”事件的数量？

我想另一种解决方案是使用像Esper这样的CEP框架，但对于我的简单需求而言似乎有点过分和麻烦。有没有人有一个完全不同的方法来建议这将有助于我的要求？感谢

Answer 1

从Cache获取活动元素的确切数量需要锁定整个缓存，这非常昂贵。您可以使用cleanUp()方法确保size不会意外地计算已被悄悄驱逐的条目。

我不会依赖来为您提供准确的结果，但它应该会显着提高结果的准确性。

Answer 2

我认为具有最接近功能的番石榴集合是MinMaxPriorityQueue，其最大尺寸有限。您必须按时间顺序排列故障事件，并定期检查第一个和最后一个元素之间的差异以及它是否已满。

但你真正想要的是一米。您可以尝试使用Coda Hale的Metrics库中的this Meter。

Answer 3

你可以装饰一个集合实现来做到这一点。像这样：

public class ExpirableArrayList<E> extends ArrayList<E> {

    private final Date creation = new Date();

    private final long timeToLiveInMs;

    public ExpirableArrayList(long timeToLiveInMs, int initialCapacity) {
        super(initialCapacity);
        this.timeToLiveInMs = timeToLiveInMs;
    }

    public ExpirableArrayList(long timeToLiveInMs) {
        this.timeToLiveInMs = timeToLiveInMs;
    }

    public ExpirableArrayList(long timeToLiveInMs, Collection<? extends E> c) {
        super(c);
        this.timeToLiveInMs = timeToLiveInMs;
    }

    private void expire() {
        if (System.currentTimeMillis() - creation.getTime() > timeToLiveInMs) {
            clear();
        }
    }

    @Override
    public int size() {
        expire();
        return super.size();
    }

    @Override
    public boolean isEmpty() {
        expire();
        return super.isEmpty();
    }

    @Override
    public boolean contains(Object o) {
        expire();
        return super.contains(o);
    }

    @Override
    public Iterator<E> iterator() {
        expire();
        return super.iterator();
    }

    @Override
    public Object[] toArray() {
        expire();
        return super.toArray();
    }

    @Override
    public <T> T[] toArray(T[] a) {
        expire();
        return super.toArray(a);
    }

    @Override
    public boolean add(E e) {
        expire();
        return super.add(e);
    }

    @Override
    public boolean remove(Object o) {
        expire();
        return super.remove(o);
    }

    @Override
    public boolean containsAll(Collection<?> c) {
        expire();
        return super.contains(c);
    }

    @Override
    public boolean addAll(Collection<? extends E> c) {
        expire();
        return super.addAll(c);
    }

    @Override
    public boolean addAll(int index, Collection<? extends E> c) {
        expire();
        return super.addAll(index, c);
    }

    @Override
    public boolean removeAll(Collection<?> c) {
        expire();
        return super.removeAll(c);
    }

    @Override
    public boolean retainAll(Collection<?> c) {
        expire();
        return super.retainAll(c);
    }

    @Override
    public E get(int index) {
        expire();
        return super.get(index);
    }

    @Override
    public E set(int index, E element) {
        expire();
        return super.set(index, element);
    }

    @Override
    public E remove(int index) {
        expire();
        return super.remove(index);
    }

    @Override
    public int indexOf(Object o) {
        expire();
        return indexOf(o);
    }

    @Override
    public int lastIndexOf(Object o) {
        expire();
        return lastIndexOf(o);
    }

    @Override
    public ListIterator<E> listIterator() {
        expire();
        return listIterator();
    }

    @Override
    public ListIterator<E> listIterator(int index) {
        expire();
        return listIterator();
    }

    @Override
    public List<E> subList(int fromIndex, int toIndex) {
        expire();
        return subList(fromIndex, toIndex);
    }
}

Answer 4

我没有使用它，但看起来this可能满足您的需求

带有过期条目的Java集合

4 个答案: