粗粒度服务的执行时间统计算法实现
一、问题描述
这是我之前工作中遇到的一个问题。一个粗粒度服务由若干细粒度服务构成,这些细粒度服务在执行过程中有可能并行,有可能串行,每个细粒度服务都一定的执行时间,这些执行时间都会写入数据库中。试设计算法统计一个粗粒度服务的执行时间。

图1.问题示例。
如图1.一个粗粒度服务由若干细粒度服务组成,这些细粒度服务有可能交叉重合也有可能完全不重合。求粗粒度服务的执行时间就等于所有细粒度服务从开始执行,到执行结束,实际占有的时间片段之和(有点拗口)。简单说就是,该粗粒度服务执行的时间范围内,如果某个时刻有至少一个该服务的子服务(细粒度服务)执行,那么就认为该服务是执行的,否则则不计算在内(比如图1.所示,执行时间t1和t2之间的时间段就不算作执行时间)。
二、实现思路
乍看之下,时间段跟时间段彼此搅在一起,要把它们的执行时间求出很不容易。这时我的想法是,先从最简单的二元关系进行考虑。任何两个时间段的关系都可以分为如下这六种关系。

图2(a).时间片段a和b的三种关系。

图2(b).时间片段a和b的另外三种关系。
如图2(a),我们可以看到时间片段a和b分别对应了包含,相交和不相交这三种关系。但同时,根据对称性,我们又得到图2(b)。实际上,我们可以让图2(b)的情形等价于图2(a),只需让时间片段a和b的身份互换即可。
值得注意的是图2(a)中,时间片段a的起始时刻都早于时间片段b的起始时刻,因此我们如果按起始时刻将所有的时间片段进行排序,那么相邻两两之间的时间片段计算就都统一为图2(a)中的三种情况了,这样就大大简化了问题的复杂度。
三、算法实现
3.1 算法一:逐一合并算法
3.1.1 算法描述
如图3.我们先将所有的时间片段按照起始时刻排序,后面的处理过程即依次判定相邻两个时间片段的三种关系,并将统计时间进行合并,合并的时间片段可以作为一个新的时间片段与后继的时间片段进行相关的计算。

图3.新的时间片段统计算法。
算法部分总共分两步,
一,将时间片段按开始时间进行排序,这里可以使用冒泡或快速排序算法。
二,1. 从第一个时间片段period 1开始,与后面的period 2 进行比较,取二者的并集,得到的新的period 2’。
2.重复上面的过程,直到最后一个时间片段并入最终的时间片段为止。
3.1.2 算法实现
为方便这里将时间都统一处理为long型,事实上,计算时间差也的确需要取date类型数据的long值再进行相关计算。
package com.example.demo.mine.time_collect; import java.util.*; import lombok.Data; import lombok.extern.slf4j.Slf4j; /** * * @author lunyu * @since 2018-03-03 */ @Slf4j public class StatisticTime { public static void main(String[] args) { // 1.产生随机数据 int size = 10; List<Period> periods = new ArrayList<Period>(); // long currentTime = System.currentTimeMillis(); //不失准确性,可以设当前时间是0 long currentTime = 0; int range = 100; int start; int end; int coi; Random random = new Random(); for (int i = 0; i < size; i++){ //区间膨胀系数 coi = random.nextInt(9)+1; start = random.nextInt(range*coi); end = random.nextInt(range*coi) + start; Period period = new Period(currentTime + start, currentTime + end); log.info("时间片段:{}-{}", period.getStartTime(), period.getEndTime()); periods.add(period); } //2.算法执行 //2.1先对各个时间段按开始时刻进行排序 sortPeriodsByStartTime(periods); //2.2对数据统计 long totalSpendTime = statisticTime(periods); log.info("总用时:{}", totalSpendTime); } /** * 对排序后的数据进行统计 * @param periods * @return */ private static long statisticTime(List<Period> periods) { long sum = periods.get(0).getEndTime() - periods.get(0).getStartTime(); for(int i = 0; i < periods.size() - 1; i++) { //1.如果(period i) 和(period i+1)相交,例: // ------------ // --------- if (periods.get(i).getEndTime() > periods.get(i + 1).getStartTime() && periods.get(i).getEndTime() < periods.get(i + 1).getEndTime()) { sum += periods.get(i + 1).getEndTime() - periods.get(i).getEndTime(); //2.如果(period i) 和(period i+1)不相交,例: //----------- // ------ }else if (periods.get(i).getEndTime() <= periods.get(i + 1).getStartTime()) { sum += periods.get(i + 1).getEndTime() - periods.get(i + 1).getStartTime(); //3.如果(period i) 包含(period i+1),例: //--------------- // ----------- }else if (periods.get(i).getEndTime() >= periods.get(i + 1).getEndTime()) { //这时什么都不做,因为(period i) 所对应的长度即为(period i) 和(period i+1)并集的时间长度。 //sum +=0; } } return sum; } /** * 对时间段按开始时间进行顺序排序,简单起见,用冒泡算法 * @param periods */ private static void sortPeriodsByStartTime(List<Period> periods) { //冒泡法,从后向前冒泡 for(int i = periods.size() - 1; i > 0; i--) { for(int j = periods.size() - 2; j >= 0; j--) { if (periods.get(j).getStartTime() > periods.get(j+1).getStartTime()) { swap(periods, j, j+1); } } } } /** * 交换对象 * @param periods * @param j * @param i * @return */ private static void swap(List<Period> periods, int j, int i) { Period tempPeriod = new Period(0, 0); tempPeriod = periods.get(j); periods.set(j, periods.get(i)); periods.set(i, tempPeriod); } /** * 区间对象 * @author lunyu * @since 2018-03-03 */ @Data private static class Period{ public Period(long startTime, long endTime) { super(); this.startTime = startTime; this.endTime = endTime; } /** * 开始时间 */ private long startTime; /** * 结束时间 */ private long endTime; } }
不难知道算法的空间复杂度为O(1),时间复杂度为O(n2) (排序冒泡算法复杂度:O(n2) + 时间片段并集计算复杂度:O(n))。
3.2 算法二:化整为零算法
3.2.1 算法描述
将每个时间片段的端点,都取出,并排序,我们就得到了n个细粒度服务分割的2n个时间点。
如图所示蓝色虚线与时间轴的交点表示每个时间端点,这些端点分割了时间从t1,t2一直持续到t2n。
将这些区间段分别与每个细粒度服务的时间片段进行比较,如果在某个细粒度服务的时间片段内,那么我们认为该时间段为执行时间。

图4.细粒度服务端点对时间的分割。
3.2.2 算法实现
import com.google.common.collect.Lists; import java.util.ArrayList; import java.util.List; import java.util.Random; import lombok.Data; import lombok.extern.slf4j.Slf4j; /** * 化整为零的方式处理代码 * @author lunyu * @since 2018-03-03 */ @Slf4j public class StatisticTimeByAll2Part { public static void main(String[] args) { // 1.产生随机数据 int size = 10; List<Period> periods = new ArrayList<Period>(); // long currentTime = System.currentTimeMillis(); //不失准确性,可以设当前时间是0 long currentTime = 0; int range = 100; int start; int end; int coi; Random random = new Random(); for (int i = 0; i < size; i++){ //区间膨胀系数 coi = random.nextInt(9)+1; start = random.nextInt(range*coi); end = random.nextInt(range*coi) + start; Period period = new Period(currentTime + start, currentTime + end); log.info("时间片段:{}-{}", period.getStartTime(), period.getEndTime()); periods.add(period); } //2.算法执行 //2.1 获取所有的时间点集合 List<Long> allTimePoints = getAllTimePoints(periods); //2.2 对所有的时间点集合进行排序 sort(allTimePoints); //2.2对数据统计 long totalSpendTime = statisticTime(allTimePoints, periods); log.info("总用时:{}", totalSpendTime); } private static long statisticTime(List<Long> allTimePoints, List<Period> periods) { long totolSpendTime = 0; for (int i = 0; i < allTimePoints.size() -1; i++){ long startTimePoint = allTimePoints.get(i); long endTimePoint = allTimePoints.get(i + 1); //对时间进行验证 for (Period period : periods){ //如果某个(细粒度)时间片段包含该分割的时间片段,则认为分割的时间片段执行时间 if (startTimePoint >= period.getStartTime() && endTimePoint <= period.getEndTime()){ totolSpendTime += (endTimePoint - startTimePoint); break; } } } return totolSpendTime; } /** * 为简单起见,用冒泡法对时间点进行排序 */ private static void sort(List<Long> allTimePoints) { //冒泡法,从后向前冒泡 for(int i = allTimePoints.size() - 1; i > 0; i--) { for(int j = allTimePoints.size() - 2; j >= 0; j--) { if (allTimePoints.get(j) > allTimePoints.get(j+1)) { swap(allTimePoints, j, j+1); } } } } /** * 交换对象 * @param allTimePoints * @param j * @param i * @return */ private static void swap(List<Long> allTimePoints, int j, int i) { long tempPeriod = allTimePoints.get(j); allTimePoints.set(j, allTimePoints.get(i)); allTimePoints.set(i, tempPeriod); } /** * 获得所有的时间点 * @param periods * @return */ private static List<Long> getAllTimePoints(List<Period> periods) { List<Long> allTimePoints = Lists.newArrayList(); for (Period period : periods){ allTimePoints.add(period.getStartTime()); allTimePoints.add(period.getEndTime()); } return allTimePoints; } /** * 区间对象 * @author lunyu * @since 2018-03-03 */ @Data private static class Period{ public Period(long startTime, long endTime) { super(); this.startTime = startTime; this.endTime = endTime; } /** * 开始时间 */ private long startTime; /** * 结束时间 */ private long endTime; } }
不难知道,需要一个list用以保存2n各时间端点,因此,该算法的空间复杂度为2O(n)。对2n个时间端点进行排序,其时间复杂度为4O(n2),每个分割的时间段与细粒度服务的时间段比较,最多比较2n*n次,其时间复杂度为O(2n2),因此总的时间复杂度为4O(n2)。
出处:https://www.cnblogs.com/lunyu/p/10561220.html
版权:本文版权归作者和博客园共有
转载:欢迎转载,但未经作者同意,必须保留此段声明;必须在文章中给出原文连接;否则必究法律责任
浙公网安备 33010602011771号