如何以并行/并发方式处理广播Intent？Android接收MEDIA_SCANNER_SCAN_FILE场景

我来给你梳理几个靠谱的方案，解决你用单线程AsyncTask处理广播效率低的问题——毕竟当客户端频繁推送文件时，单线程肯定扛不住。核心思路是：让广播接收器只做“接收+转发”的轻量操作，把真正的文件处理逻辑放到并发执行的后台线程池/协程里，避免阻塞主线程甚至触发ANR。

1. 淘汰AsyncTask，用更灵活的并发工具 #

AsyncTask早就被标记为Deprecated了，而且默认的串行执行器完全不适合并发场景。推荐用这两种方式：

方案一：自定义线程池（Java/Kotlin通用） #

先在Activity里初始化一个线程池，线程数可以根据CPU核心数调整（比如核心数+1，避免资源浪费）：

// Java示例
private ExecutorService fileExecutor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() + 1);

然后在BroadcastReceiver的onReceive里，直接把文件处理任务提交给线程池：

@Override
public void onReceive(Context context, Intent intent) {
    if (Intent.ACTION_MEDIA_SCANNER_SCAN_FILE.equals(intent.getAction())) {
        Uri fileUri = intent.getData();
        if (fileUri != null) {
            String fileName = fileUri.getPath();
            // 提交任务到线程池，并发执行
            fileExecutor.submit(() -> {
                // 这里写你的文件处理逻辑，比如扫描、解析、入库等
                handleFileScan(fileName);
            });
        }
    }
}

⚠️ 重要：Activity销毁时一定要关闭线程池，避免内存泄漏：

@Override
protected void onDestroy() {
    super.onDestroy();
    fileExecutor.shutdown(); // 优雅关闭，等待已提交任务完成
    // 如果需要强制关闭，用shutdownNow()，但可能会中断正在执行的任务
}

方案二：Kotlin协程（更简洁，推荐Kotlin项目用） #

如果你的项目是Kotlin，用协程的Dispatchers.IO处理后台任务简直不要太方便，还自带生命周期管理：
先在Activity里创建一个协程Scope：

private val scanScope = CoroutineScope(Dispatchers.Main + Job())

然后在广播接收器里切换到IO线程并发处理：

override fun onReceive(context: Context?, intent: Intent?) {
    intent?.takeIf { it.action == Intent.ACTION_MEDIA_SCANNER_SCAN_FILE }?.data?.let { uri ->
        val fileName = uri.path ?: return@let
        // 切换到IO线程，自动并发执行
        scanScope.launch(Dispatchers.IO) {
            handleFileScan(fileName)
        }
    }
}

同样，Activity销毁时要取消协程Scope，避免任务泄漏：

override fun onDestroy() {
    super.onDestroy()
    scanScope.cancel() // 取消所有未完成的协程任务
}

2. 优化广播接收器的注册逻辑 #

你现在在onResume里动态注册接收器是对的，但一定要记得在onPause里注销，不然Activity销毁后还会接收广播，导致内存泄漏：

// Java示例
private MediaScannerReceiver scannerReceiver;

@Override
protected void onResume() {
    super.onResume();
    scannerReceiver = new MediaScannerReceiver();
    IntentFilter filter = new IntentFilter(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE);
    registerReceiver(scannerReceiver, filter);
}

@Override
protected void onPause() {
    super.onPause();
    if (scannerReceiver != null) {
        unregisterReceiver(scannerReceiver);
        scannerReceiver = null;
    }
}

3. 并发处理的几个注意点 #

• 线程安全：如果多个任务要操作同一个资源（比如同一个数据库表、共享文件），一定要加锁或者用线程安全的工具类（比如ConcurrentHashMap），避免数据错乱。
• 错误处理：不管是线程池还是协程，都要捕获异常——单个任务崩溃不能影响其他任务。比如在线程池任务里加try-catch，协程里可以用CoroutineExceptionHandler统一处理。
• 避免持有Activity强引用：如果文件处理逻辑需要上下文，尽量用Application Context，不然可能导致Activity无法被回收，引发内存泄漏。
• 任务优先级：如果有些文件需要优先处理，可以自定义线程池的任务队列（比如用PriorityBlockingQueue），给高优先级任务设置更高的权重。

4. 进阶方案：用WorkManager处理持久化任务 #

如果你的文件处理需要在Activity销毁后继续执行，或者需要重试机制（比如文件暂时不可访问时重试），推荐用WorkManager。它会自动管理后台任务的生命周期，即使App被杀死也能在合适的时候恢复：

// Kotlin示例：提交文件处理任务
val fileName = uri.path ?: return
val workRequest = OneTimeWorkRequestBuilder<FileScanWorker>()
    .setInputData(workDataOf("FILE_PATH" to fileName))
    .build()
WorkManager.getInstance(context).enqueue(workRequest)

然后实现Worker类：

class FileScanWorker(appContext: Context, params: WorkerParameters) : Worker(appContext, params) {
    override fun doWork(): Result {
        val filePath = inputData.getString("FILE_PATH") ?: return Result.failure()
        return try {
            handleFileScan(filePath)
            Result.success()
        } catch (e: Exception) {
            // 可以设置重试次数
            Result.retry()
        }
    }
}

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