求指导开发可逐步提升RAM与CPU占用率的iOS/Android压力测试应用

iOS 端实现 #

CPU 逐步占用 #

核心思路是通过多线程执行计算密集型任务，控制并发线程数或任务复杂度来逐步提升CPU负载。

• 实现方式：用DispatchQueue创建后台队列，每个队列循环执行无意义的浮点运算，通过增加队列数量（不超过设备核心数）来提升占用率
• 代码示例：

var cpuQueues: [DispatchQueue] = []
var currentConcurrency = 1

func increaseCPUUsage() {
    let maxConcurrency = ProcessInfo.processInfo.activeProcessorCount
    guard currentConcurrency <= maxConcurrency else { return }
    
    let queue = DispatchQueue(label: "com.yourapp.cpu-test-\(currentConcurrency)", qos: .userInitiated)
    cpuQueues.append(queue)
    
    queue.async {
        while true {
            // 密集计算：循环执行浮点运算
            var x = 0.0
            for _ in 0..<10000 {
                x += sin(x) * cos(x)
            }
            // 加微小延迟，避免完全占满导致系统无响应（可按需调整）
            Thread.sleep(forTimeInterval: 0.001)
        }
    }
    
    currentConcurrency += 1
}

func stopCPUUsage() {
    cpuQueues.removeAll()
    currentConcurrency = 1
}

RAM 逐步占用 #

通过持续持有大量对象（如Data）来占用内存，避免被ARC自动释放，逐步增加对象数量来提升内存占用。

• 实现方式：维护全局数组，每次添加指定大小的Data块，控制每次添加的数量来调整内存增长幅度
• 代码示例：

// 全局持有，防止被自动释放
var memoryHog: [Data] = []
let chunkSize = 1024 * 1024 // 每个块1MB

func increaseRAMUsage() {
    // 每次添加10个1MB块，即单次增加10MB内存
    for _ in 0..<10 {
        if let data = Data(count: chunkSize) {
            memoryHog.append(data)
        }
    }
}

func releaseRAM() {
    memoryHog.removeAll()
}

iOS 注意事项 #

• 监听内存警告：系统内存不足时会发送UIApplicationDidReceiveMemoryWarningNotification，若测试需模拟极限场景可忽略，否则需处理避免被系统杀死
• 后台限制：iOS对后台应用的资源使用管控严格，建议在前台运行测试；若需后台持续测试，需申请对应后台模式（如音频、定位）
• 配合工具验证：用Xcode自带的Instruments里的Activity Monitor实时查看CPU、内存占用，确保实现符合预期

Android 端实现 #

CPU 逐步占用 #

通过线程池控制并发线程数，每个线程循环执行密集计算任务，逐步增加线程数来提升CPU负载。

• 实现方式：用ThreadPoolExecutor管理线程，每次增加核心线程数，线程内循环执行浮点运算
• 代码示例：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

private ExecutorService cpuExecutor;
private int currentThreadCount = 1;

public void increaseCPUUsage() {
    int maxThreads = Runtime.getRuntime().availableProcessors();
    if (currentThreadCount > maxThreads) return;
    
    if (cpuExecutor != null) {
        cpuExecutor.shutdownNow();
    }
    // 重新创建线程池，增加线程数量
    cpuExecutor = Executors.newFixedThreadPool(currentThreadCount);
    
    for (int i = 0; i < currentThreadCount; i++) {
        cpuExecutor.submit(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                // 密集计算：循环执行浮点运算
                double x = 0.0;
                for (int j = 0; j < 10000; j++) {
                    x += Math.sin(x) * Math.cos(x);
                }
                // 微小延迟，避免线程完全阻塞
                try {
                    TimeUnit.MICROSECONDS.sleep(1);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        });
    }
    
    currentThreadCount++;
}

public void stopCPUUsage() {
    if (cpuExecutor != null) {
        cpuExecutor.shutdownNow();
        cpuExecutor = null;
    }
    currentThreadCount = 1;
}

RAM 逐步占用 #

用全局集合持有大量字节数组，逐步添加数组来占用内存，避免被GC回收。

• 实现方式：维护ArrayList存储字节数组，每次添加指定大小的数组块，控制数量调整内存增长
• 代码示例：

import java.util.ArrayList;
import java.util.List;

private List<byte[]> memoryHog = new ArrayList<>();
private static final int CHUNK_SIZE = 1024 * 1024; // 每个块1MB

public void increaseRAMUsage() {
    // 每次添加10个1MB块，单次增加10MB内存
    for (int i = 0; i < 10; i++) {
        memoryHog.add(new byte[CHUNK_SIZE]);
    }
}

public void releaseRAM() {
    memoryHog.clear();
    // 测试场景下主动触发GC（实际开发不建议频繁调用）
    System.gc();
}

Android 注意事项 #

• 内存管控：通过ActivityManager.getMemoryClass()获取应用可用最大内存，避免超出导致OOM
• 权限处理：获取精确CPU占用数据需android.permission.PACKAGE_USAGE_STATS权限，需引导用户手动开启
• 工具验证：用Android Studio的Profiler实时监控CPU、内存状态，排查内存泄漏或异常占用问题

通用开发与测试建议 #

• 可调节参数：给CPU并发数、RAM块大小/增量步长设置可配置项，方便模拟不同的压力递增场景
• UI控制：添加“提升CPU”“降低CPU”“提升RAM”“释放RAM”“重置”等按钮，手动控制测试流程
• 数据展示：在UI上实时显示当前CPU占用率、内存占用量，直观查看测试效果
• 边界测试：测试到系统极限时，重点观察目标应用的卡顿、崩溃、重启等表现，同时记录测试应用自身是否被系统杀死

内容的提问来源于stack exchange，提问作者ArrchanaMohan