计算差值和计算速率的简单实现

女爷i 2022-05-11 11:04 209阅读 0赞

对于SNMPv1/v2定义的32位计数器(Counter32)是一个非负整数，其值只能增加，但不能减少，达到最大值232-1后回零，主要用于计算收到的分组数或字节数等场合。注意，Counter32没有定义初始值，所以单个Counter32的数据是没有意义的。

对Counter32类型的数据，要做差值计算。

针对某设备的指标A，按周期采集的数据，要用本次值减去上次的值做差值。需要有个缓存上次值的缓存队列，记录采集实例的具体到指标的每次采集值。做本次值减去上次的值计算时，要先判断本次值是否大于或等于上次值，否则本次数据丢弃不处理，但要缓存本次值。

![70][]

速率计算就是在本次值 – 上次值后，还要再除以两次值的采集时间差的秒数，计算公式：

(本次值 – 上次值) / (本次值采集时间 – 上次值采集时间)

另外，有的采集oid还需要和其它oid的值一起做计算，才能得到有效数据，就要做公式计算，通过一个或多个OID的采集值，计算出新的指标值。

举例某实例的一个指标的值，在3次采集时间中的值是增大的，

值200， 采集时间1536517079401 (2018/9/10 2:17:59)

值210， 采集时间1536520679042 (2018/9/10 3:17:59)

值218， 采集时间1536524279089 (2018/9/10 4:17:59)

计算差值

3:17:59 的差值计算210 – 200，得到结果值是10

4:17:59 的差值计算218 – 210，得到结果值是8

计算速率

3:17:59 的速率计算(210 – 200)/( (1536520679042 – 1536517079401)/1000)，得到结果值是0.00277

4:17:59 的差值计算(218 – 210)/( (1536524279089 – 1536520679042)/1000)，得到结果值是0.00222

下面通过代码，来做一个通用的类，能把每次采的数据送到这个类中， 直接计算差值或速率。

上代码

import java.util.HashMap;
    
    import org.apache.logging.log4j.LogManager;
    import org.apache.logging.log4j.Logger;
    
    
    /**
     * @Title: 计算差值和速率
     */
    public class PMDataCache {
    
    	private Logger log = LogManager.getLogger(PMDataCache.class);
    	
    	//缓存值不存在时返回这个值
    	public static final double NULL = -99.99d;
    
    	//单实例
        private static PMDataCache _instance = null;
        
        /** 计算差值     */
        private static HashMap<String, Double> dataMap = null;
        
        /** 计算速率     */
        private static HashMap<String, KeyAnyValue> speedMap = null;
    
        
        private PMDataCache() {
        	dataMap = new HashMap<String, Double>();
        	speedMap = new HashMap<String, KeyAnyValue>();
        }
    
        /**
         * 获得单实例
         * @return
         */
        public static PMDataCache getInstance() {
            if (_instance == null) {
                _instance = new PMDataCache();
            }
            return _instance;
        }
        
        /**
         * 取上次值
         * @param key
         * @return
         */
        public double getLastData(String key) {
        	if(dataMap.containsKey(key))
        		return (Double) dataMap.get(key);
        	return -1.0d;
        }
        
        /**
         * 保存上次值
         * @param key
         * @param value
         */
        public void putLastData(String key, double value) {
        	dataMap.put(key, value);
        }
        
        /**
         * 保存上次值
         * @param key
         * @param value
         */
        public void putLastData(String key, String value) {
        	putLastData(key, Double.parseDouble(value));
        }
        
        /**
         * 当前值-上次值
         * @param key
         * @param currentValue
         * @return
         */
        public String delta(String key, double currentValue) {
        	double deltaValue = 0.0d;
        	double lastValue = getLastData(key);
        	try {
    	    	if(lastValue != -1.0d) {
    	    		if(currentValue >= lastValue) {
    	    			deltaValue = currentValue - lastValue;
    	    			log.debug("Delta compute " + currentValue + " - " + lastValue + " = " + deltaValue);
    	    		} else {
    	        		log.warn(key + " " + currentValue + " < " + lastValue);
    	        		return null;
    	        	}
    	    	} else
    	    		return null;
        	} catch(Exception e) {
        		log.error("Delta compute error " + key, e);
        	} finally {
        		putLastData(key, currentValue);
        	}
        	return deltaValue + "";
        }
        
    	/**
    	 * 计算差值
    	 * @param key
    	 * @param value
    	 * @return 如果上次缓存值不存在, 返回-99.99d;
    	 */
        public double getDeltaValue(String key, String value) {
            double dValue = 0.0d;
            String sValue = delta(key, Double.parseDouble(value));
            if(sValue != null)
            	dValue = Double.parseDouble(sValue);
            else
            	return PMDataCache.NULL;
            return dValue;
    	}
    	
    
        /**
         * 保存上次值
         * @param key
         * @param value 值
         * @param dcTime 数据采集时间
         */
        public void putLastDataAndTime(String key, String value, long dcTime) {
        	KeyAnyValue kav = new KeyAnyValue();
        	kav.setKey(value);
        	kav.setValue(new Long(dcTime));
        	speedMap.put(key, kav);
        }
        
        /**
         * 取上次值
         * @param key
         * @return
         */
        public KeyAnyValue getLastDataAndTime(String key) {
        	if(speedMap.containsKey(key))
        		return (KeyAnyValue) speedMap.get(key);
        	return null;
        }
        
        /**
         * 速率
         * @param key
         * @param currentValue
         * @param currentTime
         * @return
         */
        public String speed(String key, double currentValue, long currentTime) {
        	double speedValue = 0.0d;
        	KeyAnyValue last = getLastDataAndTime(key);
        	try {
    	    	if(last != null) {
    	    		long lastTime = ((Long)last.getValue()).longValue();	//上次采集时间
    	        	double lastValue = Double.parseDouble(last.getKey());	//上次值
    	    		if(currentValue >= lastValue && currentTime > lastTime) {
    	    			double secTime = (currentTime - lastTime) / 1000;
    	    			speedValue = (currentValue - lastValue) / secTime;
    	    			log.debug("Speed compute (" + currentValue + " - " + lastValue + ")/" + secTime + " = " + speedValue);
    	    		} else {
    	        		log.warn(key + " " + currentValue + " < " + lastValue);
    	        		return null;
    	        	}
    	    	} else
    	    		return null;
        	} catch(Exception e) {
        		log.error("Speed compute error " + key, e);
        	} finally {
        		putLastDataAndTime(key, currentValue + "", currentTime);
        	}
        	return speedValue + "";
        }
        
    	
    	/**
    	 * 计算速率
    	 * @param key
    	 * @param value
    	 * @param currentTime
    	 * @return  如果上次缓存值不存在, 返回-99.99d;
    	 */
        public double getSpeedValue(String key, String value, long currentTime) {
            double dValue = 0.0d;
            String sValue = speed(key, Double.parseDouble(value), currentTime);
            if(sValue != null)
            	dValue = Double.parseDouble(sValue);
            else
            	return PMDataCache.NULL;
            return dValue;
    	}
        
        class KeyAnyValue implements java.io.Serializable{
        	public String key;
        	
        	public Object value;
    
        	public String getKey() {
        		return this.key;
        	}
    
        	public Object getValue() {
        		return this.value;
        	}
    
        	public void setKey(String key) {
        		this.key = key;
        	}
    
        	public void setValue(Object value) {
        		this.value = value;
        	}
        	
        	public String toString() {
        		return key + " | " + value.toString();
        	}
        }
    }

测试类

/**
     * @Title:计算差值和计算速率的测试
     */
    public class PMDataCacheTest {
    	/**
    	 * 计算差值
    	 * @param key
    	 * @param value
    	 * @return 如果上次缓存值不存在, 返回-99.99d;
    	 */
    	private double getDeltaValue(String key, String value) {
    		double dValue = 0.0d;
    		String sValue = PMDataCache.getInstance().delta(key,
    				Double.parseDouble(value));
    		if (sValue != null)
    			dValue = Double.parseDouble(sValue);
    		else
    			return PMDataCache.NULL;
    		return dValue;
    	}
    
    	/**
    	 * 计算速率
    	 * @param key
    	 * @param value
    	 * @param currentTime
    	 * @return 如果上次缓存值不存在, 返回-99.99d;
    	 */
    	private double getSpeedValue(String key, String value, long currentTime) {
    		double dValue = 0.0d;
    		String sValue = PMDataCache.getInstance().speed(key,
    				Double.parseDouble(value), currentTime);
    		if (sValue != null)
    			dValue = Double.parseDouble(sValue);
    		else
    			return PMDataCache.NULL;
    		return dValue;
    	}
    
    	/**
    	 * 测试
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		PMDataCacheTest test = new PMDataCacheTest();
    		String key = "NE-1";
    		String readIO = "1000";
    		
    		//取网元设备NE-1的readIO差值
    		double dReadIODelta = test.getDeltaValue(key + "_readIO", readIO);
    
    		//取网元设备NE-1的readIO速率
    		long thisTime = System.currentTimeMillis();
    		double dReadIOSpeed = test.getSpeedValue(key + "_readIO", readIO, thisTime);
    	}
    }

[70]: /images/20220505/f97b3a7a91624e828c807c251e34dd93.png