如何从Java codahale度量计时器中清除历史统计信息

我正在使用Java的codahale Metrics API

我们在整个系统中使用定时器来收集延迟

在性能测试期间，我们通过JMX连接到我们的系统以收集统计数据，例如平均延迟、第75百分位延迟等

问题是，除了删除所有度量对象并重新创建它们（这似乎需要很多重构）之外，有没有一种方法可以清除历史数据，这样当我们开始一个新的测试时，就不需要重新启动系统了

---

任何帮助都将不胜感激。

我不知道现有的方法，但您可以将resetTimers（）功能扩展并添加到MetricRegistry。 您必须从codahale metrics repo实施自己的水库或分支。 ResettableUniformReservoir是从UniformReservoir复制的。 默认的存储库实现是指数存储库，但需要复制的代码更多：）

公共类MyRegistry扩展了MetricRegistry{
私有最终ConcurrentMap库=新ConcurrentHashMap（）；
@凌驾
公共计时器（字符串名称）{
ResettableUniformReservoir储液罐=新的ResettableUniformReservoir（）；
水库。put（名称、水库）；
返回超级寄存器（名称、新定时器（储存器））；
}
公共无效重置计时器（）{
对于（ResettableUniformReservoir储液罐：储液罐.values（））{
reset（）；
}
}
静态类ResettableUniformReservoir执行储液罐{
私有静态最终int默认值_SIZE=1028；
私有静态最终整数位每长=63；
私有最终AtomicLong计数=新的AtomicLong（）；
私有volatile AtomicLongArray值=新的AtomicLongArray（默认大小）；
@凌驾
公共整数大小（）{
final long c=count.get（）；
如果（c>values.length（））{
返回值。length（）；
}
返回（int）c；
}
@凌驾
公共无效更新（长值）{
final long c=count.incrementAndGet（）；
如果（c）打开一个功能请求，看起来已经有一张关于重置状态的票证-
public class MyRegistry extends MetricRegistry {

    private final ConcurrentMap<String, ResettableUniformReservoir> reservoirs = new ConcurrentHashMap<>();

    @Override
    public Timer timer(String name) {
         ResettableUniformReservoir reservoir = new ResettableUniformReservoir();
         reservoirs.put(name, reservoir);
         return super.register(name, new Timer(reservoir));
    }

    public void resetTimers() {
        for (ResettableUniformReservoir reservoir : reservoirs.values()) {
            reservoir.reset();
        }
    }


    static class ResettableUniformReservoir implements Reservoir {

        private static final int DEFAULT_SIZE = 1028;
        private static final int BITS_PER_LONG = 63;

        private final AtomicLong count = new AtomicLong();
        private volatile AtomicLongArray values = new AtomicLongArray(DEFAULT_SIZE);

        @Override
        public int size() {
            final long c = count.get();
            if (c > values.length()) {
                return values.length();
            }
            return (int) c;
        }

        @Override
        public void update(long value) {
            final long c = count.incrementAndGet();
            if (c <= values.length()) {
                values.set((int) c - 1, value);
            } else {
                final long r = nextLong(c);
                if (r < values.length()) {
                    values.set((int) r, value);
                }
            }
        }

        private static long nextLong(long n) {
            long bits, val;
            do {
                bits = ThreadLocalRandom.current().nextLong() & (~(1L << BITS_PER_LONG));
                val = bits % n;
            } while (bits - val + (n - 1) < 0L);
            return val;
        }

        @Override
        public Snapshot getSnapshot() {
            final int s = size();
            final List<Long> copy = new ArrayList<Long>(s);
            for (int i = 0; i < s; i++) {
                copy.add(values.get(i));
            }
            return new UniformSnapshot(copy);
        }

        public void reset() {
            count.set(0);
            values = new AtomicLongArray(DEFAULT_SIZE);
        }
    }
}