Java与Android中等待任务列表完成的实现方案（含进度展示及AsyncTask替代）

针对你需要在后台执行任务列表时显示进度/动画、完成后启用交互元素的需求，以下是几种主流的替代方案，按推荐优先级排序：

1. 协程（Coroutines）+ ViewModel + StateFlow（推荐） #

这是当前Android官方推荐的异步处理方案，结合Jetpack组件实现生命周期安全的UI更新，代码简洁易维护。

实现示例 #

ViewModel层（处理后台任务+状态管理）

class InitViewModel : ViewModel() {
    // 用StateFlow管理初始化状态，支持生命周期感知
    val initState = MutableStateFlow<InitState>(InitState.Idle)

    sealed class InitState {
        object Idle : InitState()
        data class Loading(val progressText: String) : InitState()
        object Completed : InitState()
    }

    fun startInitTasks() {
        // 使用viewModelScope自动绑定ViewModel生命周期，避免内存泄漏
        viewModelScope.launch {
            // 更新状态：开始第一个任务
            initState.value = InitState.Loading("正在初始化配置...")
            // 模拟耗时任务1
            delay(1000)
            
            // 更新状态：开始第二个任务
            initState.value = InitState.Loading("正在加载数据...")
            // 模拟耗时任务2
            delay(1500)
            
            // 更新状态：开始第三个任务
            initState.value = InitState.Loading("正在初始化组件...")
            // 模拟耗时任务3
            delay(800)
            
            // 所有任务完成
            initState.value = InitState.Completed
        }
    }
}

UI层（Activity/Fragment，收集状态更新UI）

class InitActivity : AppCompatActivity() {
    private lateinit var viewModel: InitViewModel
    private lateinit var progressTextView: TextView
    private lateinit var actionButton: Button
    private lateinit var progressBar: ProgressBar

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_init)
        
        viewModel = ViewModelProvider(this)[InitViewModel::class.java]
        progressTextView = findViewById(R.id.progress_text)
        actionButton = findViewById(R.id.action_button)
        progressBar = findViewById(R.id.progress_bar)

        // 用lifecycleScope收集StateFlow，自动跟随Activity生命周期
        lifecycleScope.launch {
            viewModel.initState.collect { state ->
                when (state) {
                    is InitViewModel.InitState.Idle -> {
                        progressBar.visibility = View.GONE
                        progressTextView.visibility = View.GONE
                        actionButton.isEnabled = false
                    }
                    is InitViewModel.InitState.Loading -> {
                        progressBar.visibility = View.VISIBLE
                        progressTextView.visibility = View.VISIBLE
                        progressTextView.text = state.progressText
                        actionButton.isEnabled = false
                    }
                    InitViewModel.InitState.Completed -> {
                        progressBar.visibility = View.GONE
                        progressTextView.text = "初始化完成"
                        actionButton.isEnabled = true
                    }
                }
            }
        }

        // 启动初始化流程
        viewModel.startInitTasks()
    }
}

2. Executor + Handler（传统线程方案） #

如果你习惯Java线程模型，这种方案简单直接，手动管理线程池和UI线程更新，但需注意生命周期管理避免内存泄漏。

实现示例（Java） #

public class InitActivity extends AppCompatActivity {
    private TextView progressTextView;
    private Button actionButton;
    private ProgressBar progressBar;
    // 创建单线程池处理任务
    private ExecutorService executor = Executors.newSingleThreadExecutor();
    // 主线程Handler用于更新UI
    private Handler mainHandler = new Handler(Looper.getMainLooper());

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_init);
        
        progressTextView = findViewById(R.id.progress_text);
        actionButton = findViewById(R.id.action_button);
        progressBar = findViewById(R.id.progress_bar);
        actionButton.setEnabled(false);

        startInitTasks();
    }

    private void startInitTasks() {
        executor.execute(() -> {
            // 更新UI：第一个任务开始
            mainHandler.post(() -> {
                progressBar.setVisibility(View.VISIBLE);
                progressTextView.setText("正在初始化配置...");
            });
            // 模拟耗时任务1
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            // 更新UI：第二个任务开始
            mainHandler.post(() -> progressTextView.setText("正在加载数据..."));
            // 模拟耗时任务2
            try {
                Thread.sleep(1500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            // 更新UI：第三个任务开始
            mainHandler.post(() -> progressTextView.setText("正在初始化组件..."));
            // 模拟耗时任务3
            try {
                Thread.sleep(800);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            // 任务完成，更新UI启用按钮
            mainHandler.post(() -> {
                progressBar.setVisibility(View.GONE);
                progressTextView.setText("初始化完成");
                actionButton.setEnabled(true);
            });

            // 关闭线程池，释放资源
            executor.shutdown();
        });
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        // 页面销毁时强制关闭线程池，避免内存泄漏
        executor.shutdownNow();
    }
}

3. WorkManager（持久化后台任务） #

如果你的初始化任务需要在应用重启、设备重启后继续执行，WorkManager是最佳选择，它会自动调度任务并处理系统限制。

实现示例 #

定义Worker类（处理后台任务）

class InitWorker(context: Context, params: WorkerParameters) : CoroutineWorker(context, params) {
    override suspend fun doWork(): Result {
        // 任务1：更新进度
        delay(1000)
        setProgress(workDataOf("progress" to "正在初始化配置..."))
        
        // 任务2：更新进度
        delay(1500)
        setProgress(workDataOf("progress" to "正在加载数据..."))
        
        // 任务3：更新进度
        delay(800)
        setProgress(workDataOf("progress" to "初始化完成"))
        
        return Result.success()
    }
}

UI层（监听任务状态更新UI）

class InitActivity : AppCompatActivity() {
    private lateinit var progressTextView: TextView
    private lateinit var actionButton: Button
    private lateinit var progressBar: ProgressBar

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_init)
        
        progressTextView = findViewById(R.id.progress_text)
        actionButton = findViewById(R.id.action_button)
        progressBar = findViewById(R.id.progress_bar)
        actionButton.isEnabled = false

        // 创建一次性任务请求
        val workRequest = OneTimeWorkRequestBuilder<InitWorker>().build()
        // 入队任务
        WorkManager.getInstance(this).enqueue(workRequest)

        // 监听任务状态和进度
        WorkManager.getInstance(this).getWorkInfoByIdLiveData(workRequest.id)
            .observe(this) { workInfo ->
                if (workInfo != null) {
                    when (workInfo.state) {
                        WorkInfo.State.RUNNING -> {
                            progressBar.visibility = View.VISIBLE
                            progressTextView.visibility = View.VISIBLE
                            val progressText = workInfo.progress.getString("progress") ?: "初始化中..."
                            progressTextView.text = progressText
                        }
                        WorkInfo.State.SUCCEEDED -> {
                            progressBar.visibility = View.GONE
                            progressTextView.text = "初始化完成"
                            actionButton.isEnabled = true
                        }
                        WorkInfo.State.FAILED, WorkInfo.State.CANCELLED -> {
                            progressTextView.text = "初始化失败"
                            progressBar.visibility = View.GONE
                        }
                    }
                }
            }
    }
}

方案选择建议 #

• 协程+ViewModel+StateFlow：优先选择，符合Android现代架构，生命周期安全，代码简洁。
• Executor+Handler：适合传统Java开发者，快速实现但需手动管理线程和内存。
• WorkManager：仅用于需要持久化的后台任务，比如跨重启的初始化流程。

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