客户端动态降级系统

原创刘壮搜狐技术产品

本文字数：4576字

预计阅读时间：20分钟

01
背景

无论是iOS还是Android系统的设备，在线上运行时受硬件、网络环境、代码质量等多方面因素影响，可能会导致性能问题，这一类问题有些在开发阶段是发现不了的。如何在线上始终为用户提供一个相对顺畅的用户体验，是客户端开发需要考虑的一个问题。

02
服务降级、熔断

服务端有降级机制和熔断机制，在设计客户端降级系统时可以参照服务端现有方案。例如发生性能问题或网络拥堵的情况，需要减少设备和网络的负担，等恢复后再进行策略升级。

服务端降级机制，当服务端出现整体负载较大，或因为特殊原因出现数据错误，则会触发降级。不同的情况对应不同的降级策略。例如数据原因导致的，可以不去读DB数据库，直接返回缓存数据。从用户的角度来看，可能是数据更新不及时，但可以正常显示。

服务端熔断机制，熔断机制是比降级更严重的情况，当服务端中某个微服务不可用，或响应时间过长，则会触发熔断，不再调用这个服务。从用户的角度来看，可能是头像不能显示，或者页面部分模版未显示，购物车商品结算不能使用优惠券等。

03
方案简述

首先，我们需要捋清楚，客户端需要处理的问题都有哪些。我将其分为两类，性能和网速，性能又可以细化为CPU、内存、电量三类，这三类都会对App的运行造成影响。同样的，我们不能直接把性能分为好和坏两种，而是需要通过枚举的方式，将其细化为不同等级。

这里以iOS系统为例，我们需要对iOS设备CPU、内存、电量、网速进行实时监控，可以设定一个合理的间隔区间。在发生前面的性能问题时，通过对不同类型的问题进行阈值计算，从而得出对应的等级。如果级别发生变化，则通过通知的方式，告诉业务方降级或升级。

当发生降级时，业务方进行对应的降级处理，例如降低网络请求的图片尺寸。通过业务降级处理，降低系统性能消耗，让CPU、内存逐步恢复到正常区间，再进行业务升级，恢复原有业务处理规则。

通过上述方式，来保证发生性能或网络问题时，用户依然可以较为流畅的使用App，并且App内功能的正常使用不受影响。

04
整体设计

动态降级系统的设计，主要分为三个部分，职责划分如下。

DynamicLevelManager：调用monitor和decision完成分级计算，当级别发生变化时，通过通知的方式告知业务方。

DynamicLevelMonitor：监控关键性能指标，由manager定时调用。

DynamicLevelDecision：由manager将收集到的性能指标交给decision，desicion对于指标进行统一计算，并决定性能级别，并返回给manager。

05
DynamicLevelManager

DynamicLevelManager为动态降级系统的核心类，后面都称为manager，当App启动时通过openLevelAnalyze方法注册监听，从而开启一个由dispatch_source_t实现的loop，每隔1.5秒执行一次，执行时会触发dispatch_source_set_event_handler的回调方法。dispatch_source_t由手机硬件时钟触发，不受主线程卡顿影响，监听相对精确很多。

/// 开启动态降级监控系统
- (void)openLevelAnalyze {
    self.sourceHandle = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, dispatch_get_global_queue(0, 0));
    dispatch_source_set_timer(self.sourceHandle, dispatch_time(DISPATCH_TIME_NOW, 0), 1.5 * NSEC_PER_SEC, 0);
    dispatch_source_set_event_handler(self.sourceHandle, ^{
        /// 计算综合性能级别
        CGFloat cpuUsageValue = [[DynamicLevelMonitor sharedInstance] cpuUsageForApp];
        NSInteger memoryUsageValue = [[DynamicLevelMonitor sharedInstance] useMemoryForApp];
        CGFloat batteryUsageValue = [[DynamicLevelMonitor sharedInstance] batteryUsageForApp];
        [[DynamicLevelDecision sharedInstance] calculatePerformanceLevelWithMemoryValue:memoryUsageValue
                                                                               cpuValue:cpuUsageValue
                                                                           batteryValue:batteryUsageValue
                                                                        completionBlock:^(MemoryUsageLevel memoryLevel, CPUUsageLevel cpuLevel, BatteryUsageLevel batteryLevel, MultiplePerformanceLevel performanceLevel) {
            /// 判断级别是否发生变化，发送性能降级或恢复原有等级的通知
            if (performanceLevel != self.currentPerformanceLevel) {
                [self postPerformanceNotifiWithPerformanceLevel:performanceLevel
                                                    memoryLevel:memoryLevel
                                                       cpuLevel:cpuLevel
                                                   batteryLevel:batteryLevel];
            }
        }];
        
        /// 计算网络性能级别
        CGFloat networkSpeed = [[QUICManager shareQUICManager] currentNetworkSpeed];
        [[DynamicLevelDecision sharedInstance] calculateNetworkLevelWithNetworkSpeed:networkSpeed completionBlock:^(NetworkSpeedLevel speedLevel) {
            /// 判断级别是否发生变化，发送网络降级或恢复原有等级的通知
            if (speedLevel != self.currentNetworkSpeedLevel) {
                [self postPerformanceNotifiWithNetworkSpeedLevel:speedLevel];
            }
        }];
    });
    dispatch_resume(self.sourceHandle);
}

- (void)closeLevelAnalyze {
    dispatch_source_cancel(self.sourceHandle);
}

/// 发送性能降级或恢复原有等级的通知
- (void)postPerformanceNotifiWithPerformanceLevel:(MultiplePerformanceLevel)performanceLevel
                                      memoryLevel:(MemoryUsageLevel)memoryLevel
                                         cpuLevel:(CPUUsageLevel)cpuLevel
                                     batteryLevel:(BatteryUsageLevel)batteryLevel {
    [[NSNotificationCenter defaultCenter] postNotificationName:@"PerformanceLevelChanged"
                                                        object:nil
                                                      userInfo:@{@"performanceLevel": @(performanceLevel),
                                                                 @"memoryLevel": @(memoryLevel),
                                                                 @"cpuLevel": @(cpuLevel),
                                                                 @"batteryLevel": @(batteryLevel)}];
}

/// 发送网络降级或恢复原有等级的通知
- (void)postPerformanceNotifiWithNetworkSpeedLevel:(NetworkSpeedLevel)networkSpeedLevel {
    [[NSNotificationCenter defaultCenter] postNotificationName:@"NetworkSpeedLevelChanged"
                                                        object:nil
                                                      userInfo:@{@"networkSpeedLevel": @(networkSpeedLevel)}];
}

manager对外界提供的消息回调分为两类，一个是由CPU、内存、电量，综合计算出的性能分级performanceLevel，另一个是网速分级networkSpeedLevel。

5.1 performanceLevel

在handler方法中会调用monitor的cpuUsageForApp方法获取CPU的使用率，取值范围是0-1，当CPU发生超频，也有超过1的情况。调用monitor的useMemoryForApp方法获取内存使用率，取值范围是0-1。调用monitor的batteryUsageForApp方法获取剩余电量，取值范围是0-100。

获取这些信息后，调用decision的calculatePerformanceLevel方法，将信息交由decision进行综合计算，计算后返回结果为四个值。

1、performanceLevel：综合性能分级

2、memoryLevel：内存占用率分级

3、cpuLevel：CPU使用率分级

4、batteryLevel：电量使用分级

这里的核心就是performanceLevel综合分级，类型为MultiplePerformanceLevel，这是根据内存、电量、CPU综合计算出来的结果。上述的四个值通过枚举定义，具体定义如下。

/// 综合性能枚举
typedef NS_ENUM(NSUInteger, MultiplePerformanceLevel) {
    MultiplePerformanceLevelNormal,
    MultiplePerformanceLevelLow,
    MultiplePerformanceLevelVeryLow,
};

/// cpu使用率枚举，overclock表示cpu已超频
typedef NS_ENUM(NSUInteger, CPUUsageLevel) {
    CPUUsageLevelLow,
    CPUUsageLevelHigh,
    CPUUsageLevelOverclock,
};

/// 内存使用级别枚举
typedef NS_ENUM(NSUInteger, MemoryUsageLevel) {
    MemoryUsageLevelLow,
    MemoryUsageLevelMiddle,
    MemoryUsageLevelHigh,
};

/// 电量使用枚举，high表示使用较多，电量剩余1%
typedef NS_ENUM(NSUInteger, BatteryUsageLevel) {
    BatteryUsageLevelLow,
    BatteryUsageLevelMiddle,
    BatteryUsageLevelHigh,
};

拿到这些性能level后，会判断performanceLevel是否发生变化，如果低于当前level，则发生降级。如果高于当前level，则表示性能恢复。随后会调用NSNotificationCenter以通知的形式进行消息通知，通知名为PerformanceLevelChanged，并这四个分级参数传递过去。如果level没有发生改变，则不会发出消息通知。

5.2 speedLevel

另一个是网速分级，这个指标并没有归类于性能分级中，因为和性能分级并不是一类。

在handler方法中会调用网络库QUICManager的currentNetworkSpeed方法，获得当前网速，单位是kb每秒。这里的QUICManager是公司自研的网络库，提供当前实时网速。

拿到网速数据后，会调用decision的calculateNetworkLevel方法，交给decision进行计算。decision会返回一个speedLevel当前网速级别，其类型是NetworkSpeedLevel，分为三个级别。

/// 当前网速枚举
typedef NS_ENUM(NSUInteger, NetworkSpeedLevel) {
    NetworkSpeedLevelNormal,
    NetworkSpeedLevelLow,
    NetworkSpeedLevelVeryLow,
};

拿到这些信息后，会判断speedLevel是否发生改变，如果低于当前level，则表示网速发生劣化。如果高于当前level，则表示网速恢复。随后会调用NSNotificationCenter以通知的形式进行消息通知，通知名为NetworkSpeedLevelChanged，并将speedLevel参数传递过去。如果level没有发生改变，则不会发出消息通知。

06
DynamicLevelDecision

Decision负责接收manager传入的数据信息，返回对应的性能级别。在计算时，会先对传入的参数进行计算，计算出对应单个性能参数的level分级，再计算performanceLevel分级。

/// 进行综合性能计算
- (void)calculatePerformanceLevelWithMemoryValue:(NSInteger)memoryValue
                                        cpuValue:(CGFloat)cpuValue
                                    batteryValue:(CGFloat)batteryValue
                                 completionBlock:(DynamicPerformanceLevelBlock)completionBlock {
    MemoryUsageLevel memoryLevel = [self calculateMemoryUsageLevelWithMemoryValue:memoryValue];
    CPUUsageLevel cpuLevel = [self calculateCPUUsageLevelWithCpuValue:cpuValue];
    BatteryUsageLevel batteryLevel = [self calculateBatteryUsageLevelWithBatteryValue:batteryValue];
    
    MultiplePerformanceLevel performanceLevel = MultiplePerformanceLevelNormal;
    if (batteryLevel == BatteryUsageLevelHigh) {
        performanceLevel = MultiplePerformanceLevelVeryLow;
    }
    else if (cpuLevel == CPUUsageLevelOverclock && memoryLevel == MemoryUsageLevelHigh) {
        performanceLevel = MultiplePerformanceLevelVeryLow;
    }
    else if (batteryLevel >= 1 && memoryLevel >= 1) {
        performanceLevel = MultiplePerformanceLevelLow;
    }
    else if (batteryLevel >= 1 && cpuLevel >= 1) {
        performanceLevel = MultiplePerformanceLevelLow;
    }
    else if (memoryLevel >= 1 && cpuLevel >= 1) {
        performanceLevel = MultiplePerformanceLevelLow;
    }
    
    if (completionBlock) {
        completionBlock(memoryLevel, cpuLevel, batteryLevel, performanceLevel);
    }
}

/// 进行网速级别计算
- (void)calculateNetworkLevelWithNetworkSpeed:(CGFloat)networkSpeed
                              completionBlock:(DynamicNetworkSpeedLevelBlock)completionBlock {
    [self.networkSpeedArray addObject:@(networkSpeed)];
    if (self.networkSpeedArray.count > 5) {
        [self.networkSpeedArray removeObjectsInRange:NSMakeRange(0, self.networkSpeedArray.count - 5)];
    }
    
    __block NSInteger middleCount = 0;
    __block NSInteger highCount = 0;
    [self.networkSpeedArray enumerateObjectsUsingBlock:^(NSNumber * _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
        if (obj.floatValue <= 200) {
            middleCount++;
        }
        if (obj.floatValue <= 50) {
            highCount++;
        }
    }];
    
    NetworkSpeedLevel networkThreshold = NetworkSpeedLevelNormal;
    if (highCount >= 3) {
        networkThreshold = NetworkSpeedLevelVeryLow;
    } else if (middleCount >= 3) {
        networkThreshold = NetworkSpeedLevelLow;
    }
    
    if (completionBlock) {
        completionBlock(networkThreshold);
    }
}

/// 计算内存使用级别
- (MemoryUsageLevel)calculateMemoryUsageLevelWithMemoryValue:(NSInteger)memoryValue {
    [self.memoryUsageArray addObject:@(memoryValue)];
    if (self.memoryUsageArray.count > 5) {
        [self.memoryUsageArray removeObjectsInRange:NSMakeRange(0, self.memoryUsageArray.count - 5)];
    }
    
    __block NSInteger middleCount = 0;
    __block NSInteger highCount = 0;
    [self.memoryUsageArray enumerateObjectsUsingBlock:^(NSNumber * _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
        if (obj.floatValue > 0.45) {
            highCount++;
        }
        if (obj.floatValue > 0.4) {
            middleCount++;
        }
    }];
    
    MemoryUsageLevel memoryThreshold = MemoryUsageLevelLow;
    if (highCount >= 3) {
        memoryThreshold = MemoryUsageLevelHigh;
    } else if (middleCount >= 3) {
        memoryThreshold = MemoryUsageLevelMiddle;
    }
    return memoryThreshold;
}

/// 计算CPU使用级别
- (CPUUsageLevel)calculateCPUUsageLevelWithCpuValue:(CGFloat)cpuValue {
    [self.cpuUsageArray addObject:@(cpuValue)];
    /// cpu level calculate
    return CPUUsageLevelLow;
}

/// 计算电量使用级别
- (BatteryUsageLevel)calculateBatteryUsageLevelWithBatteryValue:(CGFloat)batteryValue {
    [self.batteryUsageArray addObject:@(batteryValue)];
    /// battery level calculate
    return BatteryUsageLevelLow;
}

6.1 单个性能参数level计算

CPU：传入数值>0.8，也就是CPU使用率超过80%，CPUUsageLevel等于levelMiddle，如果CPU使用率超过100%，则发生CPU超频，CPUUsageLevel等于levelHigh。

内存：因为在iOS系统中，App最多可以使用设备总内存的50%，内存使用率超过40%，MemoryUsageLevel等于levelMiddle，如果内存使用率超过45%，MemoryUsageLevel等于levelHigh。

电量：传入数值<6%，则表示低电量，BatteryUsageLevel等于levelMiddle，传入数值<1%，则表示到达临界值，BatteryUsageLevel等于levelHigh。

6.2 performanceLevel计算

得到上述三个性能参数的level后，manager会调用decision的calculatePerformanceLevel方法，通过方法返回值获得performanceLevel，其类型为MultiplePerformanceLevel。计算performanceLevel时，根据先后顺序会有如下条件，条件之间彼此互斥。

1、判断batteryLevel是否等于levelHigh，如果是的话表示电量接近临界值，则直接将performanceLevel设置为veryLow；

2、cpuLevel等于overclock，memoryLevel等于high，则表示CPU处于超频状态，并且内存占用也处于非常高的状态，此时很容易被系统强杀造成OOM，直接将performanceLevel设置为veryLow；

3、batteryLevel、cpuLevel、memoryLevel，任意两者构成middle或high，则将performanceLevel设置为low。

6.3 speedLevel计算

Manager调用decision的calculateNetworkLevel方法，获取网络变化指标。在计算speedLevel时，传入的网速小于200kb/s，则表示网速较低，将speedLevel设置为low，传入的网速小于50kb/s，则表示网速非常慢，将speedLevel设置为veryLow。

6.3.1 性能计算窗口

在获取性能参数时，不能以某一个时间点的性能数据作为计算依据，而是以一个时间窗口的多条性能数据作为计算依据，这样更能反映这个时间段的综合性能。

性能计算窗口是基于handler的回调，收集从当前次到前四次，这连续五次的数据，综合进行计算。例如NetworkSpeedLevel的计算，如果超过三次网速都小于50kb/s，则NetworkSpeedLevel等于veryLow，如果超过三次网速都小于200kb/s，则NetworkSpeedLevel等于low。

从实现的角度，性能计算窗口时通过NSMutableArray实现的，通过FIFO策略进行淘汰，始终保留相邻的五条数据。

07
DynamicLevelMonitor

Monitor的作用是提供获取系统性能信息的方法，在handler中调用的三个monitor的方法，内部实现如下。

/// 当前app内存使用量，返回单位百分比
- (NSInteger)useMemoryForApp {
    task_vm_info_data_t vmInfo;
    mach_msg_type_number_t count = TASK_VM_INFO_COUNT;
    kern_return_t kernelReturn = task_info(mach_task_self(), TASK_VM_INFO, (task_info_t) &vmInfo, &count);
    if (kernelReturn == KERN_SUCCESS) {
        int64_t memoryUsageInByte = (int64_t) vmInfo.phys_footprint;
        int64_t totalMemory = [[NSProcessInfo processInfo] physicalMemory];
        return memoryUsageInByte / totalMemory;
    } else {
        return -1;
    }
}

/// 当前app的CPU使用率
- (CGFloat)cpuUsageForApp {
    kern_return_t           kr;
    thread_array_t          thread_list;
    mach_msg_type_number_t  thread_count;
    thread_info_data_t      thinfo;
    mach_msg_type_number_t  thread_info_count;
    thread_basic_info_t     basic_info_th;
    
    kr = task_threads(mach_task_self(), &thread_list, &thread_count);
    if (kr != KERN_SUCCESS)
        return -1;
    
    float total_cpu_usage = 0;
    for (int i = 0; i < thread_count; i++) {
        thread_info_count = THREAD_INFO_MAX;
        kr = thread_info(thread_list[i], THREAD_BASIC_INFO, (thread_info_t)thinfo, &thread_info_count);
        if (kr != KERN_SUCCESS) {
            return -1;
        }
        
        basic_info_th = (thread_basic_info_t)thinfo;
        if (!(basic_info_th->flags & TH_FLAGS_IDLE)) {
            total_cpu_usage += basic_info_th->cpu_usage / (float)TH_USAGE_SCALE;
        }
    }
    
    kr = vm_deallocate(mach_task_self(), (vm_offset_t)thread_list, thread_count * sizeof(thread_t));
    assert(kr == KERN_SUCCESS);
    return total_cpu_usage;
}

UseMemoryForApp方法实现，通过系统task_info函数获取到当前App已使用的内存，通过NSProcessInfo的physicalMemory方法获得设备的物理内存，二者的单位都是bytes，通过计算task_info占physicalMemory的百分比，得到App已使用的内存的百分比。

CpuUsageForApp方法实现，通过系统task_threads函数获得所有线程的信息thread_list，thread_list是一个数组，遍历thread_list得到thread_info_t单个线程的信息，累加thread_info_t的cpu_usage属性(cpu_usage属性表示当前线程使用CPU的百分比)，得到总的CPU使用占比。

BatteryUsageForApp方法实现，设置系统UIDevice的batteryMonitoringEnabled为true，开启电量监听。并通过通知接收电量变化的回调，回调的单位是0~1，再乘以100返回给manager。

08
业务方

业务方收到PerformanceLevelChanged的消息后，可以基于performanceLevel的综合性能进行判断，如果是veryLow，可以暂停流内秒播处理，也就是在视频流中，滑动到下一条视频不会自动播放。

也可以基于单个性能level进行判断，例如batteryLevel指标为middle或low，也就是电量低于6%时，可以提示用户先不进行视频文件缓存等非常消耗性能的操作，以避免因为消耗性能的操作，导致手机自动关机。

业务方收到NetworkSpeedLevelChanged的消息后，可以根据通知传过来的speedLevel参数，low和veryLow可以有不同的处理。例如可以降低向服务端获取图片的尺寸，low可以将图片尺寸压缩80%，如果是veryLow可以将图片尺寸压缩60%，可以明显提升弱网下，向服务器获取图片的速度。压缩比率在请求图片URL时，在URL中拼接发送给服务端，服务端会返回对应压缩比率的图片。

继续滑动看下一个

客户端动态降级系统

01背景

02服务降级、熔断

03方案简述

04整体设计

05DynamicLevelManager