Android PMS 提升开机速度优化方案

Android PMS扫描优化分步说明

1. 核心思路分析

• 问题定位：PMS在开机时单线程扫描APK导致启动延迟
• 优化方向：利用多线程并行解析APK文件
• 关键技术点：
  • 基于CPU核心数动态分配线程
  • 线程安全的APK解析队列
  • 并行处理与主流程的协同机制

2. 多线程架构设计

2.1 线程池配置

// 根据CPU核心数动态计算线程数
public static int deriveCoreNum() {
    File cpuDir = new File("/sys/devices/system/cpu/");
    File[] cpus = cpuDir.listFiles(pathname -> 
        Pattern.matches("cpu[0-9]+", pathname.getName()));
    return Math.max(cpus != null ? cpus.length : 4, 4); // 保底4线程
}

2.2 任务分发策略

void parallelTakeAndScanPackageLI(File dir, ParallelPackageParser parser, 
                                 int totalFiles, int parseFlags, int scanFlags) {
    int threadNum = deriveCoreNum();
    int perThreadFiles = (int) Math.ceil((double)totalFiles / threadNum);

    CountDownLatch latch = new CountDownLatch(threadNum);

    for (int i=0; i<threadNum; i++) {
        final int start = i * perThreadFiles;
        final int end = Math.min(start + perThreadFiles, totalFiles);

        new Thread(() -> {
            for (int j=start; j<end; j++) {
                processSingleFile(parser.take(), parseFlags, scanFlags);
            }
            latch.countDown();
        }).start();
    }

    latch.await(30, TimeUnit.SECONDS); // 超时保护
}

3. 关键代码实现

3.1 并行解析控制器

class ParallelPackageParser implements AutoCloseable {
    private final BlockingQueue<ParseTask> taskQueue = new LinkedBlockingQueue<>();
    private final ExecutorService parserPool = Executors.newFixedThreadPool(deriveCoreNum());

    void submit(File apkFile, int flags) {
        parserPool.submit(() -> {
            ParseResult result = parsePackage(apkFile, flags);
            taskQueue.offer(result);
        });
    }

    ParseResult take() throws InterruptedException {
        return taskQueue.poll(5, TimeUnit.SECONDS);
    }
}

3.2 线程安全处理方法

void processSingleFile(ParseResult result, int parseFlags, int scanFlags) {
    synchronized (mInstallLock) { // 全局安装锁
        try {
            if (result.pkg != null) {
                scanPackageTraced(result.pkg, parseFlags, scanFlags);
            }
        } catch (PackageManagerException e) {
            handleParseError(result.scanFile, e);
        }
    }
}

4. 性能优化措施

4.1 负载均衡策略

// 基于文件大小的动态分配
List<File> sortedFiles = Arrays.stream(files)
    .sorted((f1, f2) -> Long.compare(f2.length(), f1.length()))
    .collect(Collectors.toList());

// 轮询分配保证均衡
List<File>[] partitions = new List[threadNum];
for (int i=0; i<sortedFiles.size(); i++) {
    int target = i % threadNum;
    partitions[target].add(sortedFiles.get(i));
}

4.2 缓存预热机制

// 预加载核心系统包
Set<String> corePackages = new HashSet<>(Arrays.asList(
    "android", "com.android.systemui", "com.android.settings"));

void preloadCorePackages() {
    corePackages.forEach(pkg -> {
        PackageInfo info = mCache.get(pkg);
        if (info == null) {
            forceLoadPackage(pkg);
        }
    });
}

5. 异常处理机制

5.1 错误隔离策略

void handleParseError(File apkFile, Exception e) {
    Log.w(TAG, "Parse failed: " + apkFile.getName(), e);

    if (e instanceof PackageParserException) {
        int errorCode = ((PackageParserException)e).error;
        if (isCriticalError(errorCode)) {
            quarantineApk(apkFile); // 隔离问题APK
        }
    }
}

5.2 重试机制

final int MAX_RETRY = 3;
ParseResult parseWithRetry(File apkFile, int flags) {
    int attempts = 0;
    while (attempts < MAX_RETRY) {
        try {
            return parsePackage(apkFile, flags);
        } catch (IOException e) {
            if (++attempts == MAX_RETRY) throw e;
        }
    }
    return null;
}

6. 兼容性保障

6.1 版本适配方案

@TargetApi(Build.VERSION_CODES.Q)
void scanPackageModern(Package pkg) {
    // Android 10+新特性
}

@SuppressWarnings("deprecation")
void scanPackageLegacy(Package pkg) {
    // 兼容旧版本逻辑
}

6.2 SELinux策略

# system/sepolicy/private/pkgmgr.te
allow pkgmgr system_data_file:dir { search write };
allow pkgmgr apk_data_file:file { read getattr };

7. 验证与测试

7.1 性能基准测试

bash
# 扫描耗时测试
adb shell dumpsys package timing | grep "Scan duration"
# 线程状态监控
adb shell "top -n 1 | grep PackageManager"

7.2 自动化测试用例

@Test
public void testConcurrentScanning() {
    List<File> mockApks = generateMockApks(100); // 生成100个测试APK
    long singleThreadTime = measureScanTime(mockApks, 1);
    long multiThreadTime = measureScanTime(mockApks, 4);

    assertTrue(multiThreadTime < singleThreadTime * 0.6); // 预期提速40%
}

通过上述多线程优化方案，可在Android 10系统上实现APK扫描速度的显著提升。关键点包括动态线程分配、线程安全控制、负载均衡策略及完善的异常处理机制。建议结合设备实际硬件配置调整线程参数，并通过系统级测试验证优化效果。