如何从后台通过WorkManager Worker安全更新Realm数据库？

核心原则 #

• 确保Realm实例在Worker生命周期内独立管理，禁止跨线程/进程共享
• 使用WorkManager的CoroutineWorker而非普通Worker，天然适配协程调度
• 严格遵循Realm线程规则：Realm对象仅在创建它的协程/线程中使用
• 操作完成后立即关闭Realm实例，避免资源泄漏与锁持有

步骤1：适配Dagger2到WorkManager #

Worker由WorkManager实例化，需自定义WorkerFactory实现Dagger依赖注入：

1. 实现通用Worker工厂类

class DaggerWorkerFactory @Inject constructor(
    private val workerFactories: Map<Class<out ListenableWorker>, @JvmSuppressWildcards Provider<ChildWorkerFactory>>
) : WorkerFactory() {
    override fun createWorker(
        appContext: Context,
        workerClassName: String,
        workerParameters: WorkerParameters
    ): ListenableWorker? {
        val workerClass = Class.forName(workerClassName).asSubclass(ListenableWorker::class.java)
        val factory = workerFactories[workerClass] ?: return null
        return factory.get().create(appContext, workerParameters)
    }

    interface ChildWorkerFactory {
        fun create(appContext: Context, params: WorkerParameters): ListenableWorker
    }
}

2. 在Dagger模块中绑定Worker工厂

@Module
abstract class WorkerModule {
    @Binds
    @IntoMap
    @WorkerKey(RealmUpdateWorker::class)
    abstract fun bindRealmUpdateWorkerFactory(factory: RealmUpdateWorker.Factory): ChildWorkerFactory

    @Binds
    abstract fun bindWorkerFactory(factory: DaggerWorkerFactory): WorkerFactory
}

3. 在Application中初始化WorkManager时配置自定义工厂

class MyApp : Application(), HasAndroidInjector {
    @Inject lateinit var workerFactory: WorkerFactory

    override fun onCreate() {
        super.onCreate()
        DaggerAppComponent.factory().create(this).inject(this)
        
        val config = Configuration.Builder()
            .setWorkerFactory(workerFactory)
            .build()
        WorkManager.initialize(this, config)
    }
}

步骤2：实现协程安全的Realm更新Worker #

使用CoroutineWorker封装Realm操作，严格管理实例生命周期：

class RealmUpdateWorker(
    appContext: Context,
    params: WorkerParameters,
    private val realmConfig: RealmConfiguration // Dagger注入Realm配置，而非直接取默认实例
) : CoroutineWorker(appContext, params) {

    class Factory @Inject constructor(
        private val realmConfig: RealmConfiguration
    ) : ChildWorkerFactory {
        override fun create(appContext: Context, params: WorkerParameters): ListenableWorker {
            return RealmUpdateWorker(appContext, params, realmConfig)
        }
    }

    override suspend fun doWork(): Result {
        return withContext(Dispatchers.IO) {
            var realm: Realm? = null
            try {
                realm = Realm.getInstance(realmConfig)
                // 所有更新操作包裹在Realm事务中，自动处理线程安全
                realm.executeTransaction { realm ->
                    // 从Worker参数中获取Fcm传递的更新数据
                    val updateData = inputData.getString("update_payload")
                    // 示例：更新目标数据对象
                    val target = realm.where<YourModel>().equalTo("id", "target_id").findFirst()
                    target?.apply {
                        // 执行具体更新逻辑
                        field1 = updateData?.split(",")?.get(0) ?: field1
                        updateTime = System.currentTimeMillis()
                    }
                }
                Result.success()
            } catch (e: Exception) {
                // 异常时触发重试，可根据需求调整重试策略
                Result.retry()
            } finally {
                realm?.close() // 必须关闭实例，释放资源与锁
            }
        }
    }
}

步骤3：冲突与死锁预防策略 #

• 独立实例管理：每个Worker创建专属Realm实例，绝不跨协程/线程传递Realm对象
• 事务包裹更新：所有写操作必须放在executeTransaction中，Realm自动处理锁竞争
• 拆分大事务：将批量更新拆分为多个小事务，减少锁持有时间，降低死锁概率
• 控制重复任务：使用WorkManager的唯一任务机制，避免同时触发多个相同更新：

// 触发Worker时使用唯一任务名
WorkManager.getInstance(context).enqueueUniqueWork(
    "Realm_Update_Task",
    ExistingWorkPolicy.REPLACE, // 已有相同任务则替换，避免重复执行
    workRequest
)

• 开发阶段监控：开启Realm日志观察锁状态，提前排查潜在冲突：

val realmConfig = RealmConfiguration.Builder()
    .log(LogLevel.ALL)
    .build()

步骤4：FirebaseMessaging触发Worker逻辑 #

在FirebaseMessagingService中收到消息后，直接调度WorkManager任务，避免在后台服务中直接操作数据库：

class MyFcmService : FirebaseMessagingService() {
    override fun onMessageReceived(remoteMessage: RemoteMessage) {
        super.onMessageReceived(remoteMessage)
        val updatePayload = remoteMessage.data["update_payload"] ?: return
        
        val workRequest = OneTimeWorkRequestBuilder<RealmUpdateWorker>()
            .setInputData(workDataOf("update_payload" to updatePayload))
            .setConstraints(Constraints.Builder()
                .setRequiredNetworkType(NetworkType.CONNECTED) // 可选：仅在联网时执行
                .build())
            .build()

        WorkManager.getInstance(this).enqueueUniqueWork(
            "Realm_Update_Task",
            ExistingWorkPolicy.REPLACE,
            workRequest
        )
    }
}

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