在后台线程运行Service时，如何实现进度条动态更新？

嘿，我来帮你搞定这个进度条不更新的问题！你把任务移到Service里后能重复加载表格，但进度条没动静，核心原因其实是Service和UI线程（你的Activity）之间没做好通信——Service在后台跑着进度更新，但UI根本收不到这个信号呀！

下面给你两种实用的解决方案，都是Android开发里常用的，你可以根据自己的项目情况选：

方案一：用LiveData（推荐，Jetpack组件更省心） #

LiveData天生就是用来在组件之间传递数据的，而且能自动感知生命周期，不会造成内存泄漏，非常适合这种场景：

1. 在你的Service里定义LiveData
   先创建一个MutableLiveData来存进度值，然后在后台加载任务里更新它：

class DataLoadingService : Service() {
    // 用来传递进度的LiveData
    val progressLiveData = MutableLiveData<Int>()
    // 后台任务的CoroutineScope，用来管理加载任务
    private val serviceScope = CoroutineScope(Dispatchers.IO + SupervisorJob())

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        // 每次点击按钮时，先取消之前的任务，避免多个任务同时跑
        serviceScope.cancel()
        serviceScope.launch {
            // 先获取数据库里要加载的总数据量，用来计算进度
            val totalCount = getTotalDataCountFromDb()
            for (i in 0..totalCount) {
                // 加载单条/部分数据到表格
                loadDataChunk(i)
                // 计算当前进度
                val currentProgress = (i * 100) / totalCount
                // 用postValue把进度传到主线程（因为后台线程不能直接更UI相关的LiveData）
                progressLiveData.postValue(currentProgress)
                // 这里可以加个小延迟模拟加载，实际开发去掉就行
                delay(30)
            }
            // 加载完成后把进度设为100
            progressLiveData.postValue(100)
        }
        return START_STICKY
    }

    // 别忘了在Service销毁时取消任务，避免内存泄漏
    override fun onDestroy() {
        super.onDestroy()
        serviceScope.cancel()
    }

    // 这里是Service的Binder，用来让Activity获取Service实例
    inner class LocalBinder : Binder() {
        fun getService(): DataLoadingService = this@DataLoadingService
    }

    override fun onBind(intent: Intent): IBinder {
        return LocalBinder()
    }
}

2. 在Activity里绑定Service并观察进度
   点击按钮时启动Service，同时绑定Service获取它的实例，然后观察LiveData来更新进度条：

class MainActivity : AppCompatActivity() {
    private var loadingService: DataLoadingService? = null
    private var isServiceBound = false

    // 用来绑定Service的连接对象
    private val serviceConnection = object : ServiceConnection {
        override fun onServiceConnected(className: ComponentName, service: IBinder) {
            val binder = service as DataLoadingService.LocalBinder
            loadingService = binder.getService()
            isServiceBound = true
            // 观察进度变化，更新进度条
            loadingService?.progressLiveData?.observe(this@MainActivity) { progress ->
                yourProgressBar.progress = progress
            }
        }

        override fun onServiceDisconnected(arg0: ComponentName) {
            isServiceBound = false
            loadingService = null
        }
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // 绑定Service，要在onCreate里做
        Intent(this, DataLoadingService::class.java).also { intent ->
            bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE)
        }

        // 按钮点击事件，启动Service开始加载
        loadButton.setOnClickListener {
            startService(Intent(this, DataLoadingService::class.java))
        }
    }

    // 页面销毁时解绑Service，避免内存泄漏
    override fun onDestroy() {
        super.onDestroy()
        if (isServiceBound) {
            unbindService(serviceConnection)
            isServiceBound = false
        }
    }
}

方案二：用广播（适合不需要紧密绑定Service的场景） #

如果你的项目没用到Jetpack，或者不想用绑定Service的方式，用广播传递进度也是个不错的选择：

1. Service里发送进度广播
   每次进度更新时，发送一个自定义广播，把进度值放在Intent的Extra里：

class DataLoadingService : Service() {
    private val serviceScope = CoroutineScope(Dispatchers.IO + SupervisorJob())

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        serviceScope.cancel()
        serviceScope.launch {
            val totalCount = getTotalDataCountFromDb()
            for (i in 0..totalCount) {
                loadDataChunk(i)
                val currentProgress = (i * 100) / totalCount
                // 发送广播
                val progressIntent = Intent("com.yourpackage.PROGRESS_UPDATE")
                progressIntent.putExtra("PROGRESS_VALUE", currentProgress)
                sendBroadcast(progressIntent)
                delay(30)
            }
            // 加载完成发送100%进度
            val finishIntent = Intent("com.yourpackage.PROGRESS_UPDATE")
            finishIntent.putExtra("PROGRESS_VALUE", 100)
            sendBroadcast(finishIntent)
        }
        return START_STICKY
    }

    override fun onDestroy() {
        super.onDestroy()
        serviceScope.cancel()
    }

    override fun onBind(intent: Intent): IBinder? {
        return null
    }
}

2. Activity里注册广播接收器
   在Activity里动态注册一个广播接收器，接收进度更新并刷新进度条：

class MainActivity : AppCompatActivity() {
    private lateinit var progressReceiver: BroadcastReceiver

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // 初始化广播接收器
        progressReceiver = object : BroadcastReceiver() {
            override fun onReceive(context: Context?, intent: Intent?) {
                val progress = intent?.getIntExtra("PROGRESS_VALUE", 0) ?: 0
                yourProgressBar.progress = progress
            }
        }

        // 注册广播接收器，指定要接收的广播action
        registerReceiver(progressReceiver, IntentFilter("com.yourpackage.PROGRESS_UPDATE"))

        // 按钮点击启动Service
        loadButton.setOnClickListener {
            startService(Intent(this, DataLoadingService::class.java))
        }
    }

    // 页面销毁时注销广播，避免内存泄漏
    override fun onDestroy() {
        super.onDestroy()
        unregisterReceiver(progressReceiver)
    }
}

几个关键注意点 #

• 不管用哪种方案，数据库加载任务一定要放在后台线程（比如上面用的Coroutine Dispatchers.IO），绝对不能放在Service的主线程里，不然会阻塞UI，甚至导致ANR。
• 每次点击按钮时，记得取消Service里之前的任务，避免多个加载任务同时运行，导致进度条数值混乱。
• 如果用LiveData的话，一定要通过postValue更新，不能用setValue，因为setValue只能在主线程调用，后台线程用会报错。

这样改完之后，你再点击按钮加载数据，进度条应该就能正常跟着更新啦！

内容的提问来源于stack exchange，提问作者Mr. Crow