Android多进程数据共享：SharedPreferences替代方案详解

发布于：2025-06-23 ⋅ 阅读:(12) ⋅ 点赞:(0)

在Android多进程应用中，SharedPreferences的同步问题常常困扰开发者。本文将深入分析问题根源并提供多种高效解决方案，助你彻底解决多进程数据同步难题。

问题背景：SharedPreferences的多进程缺陷

当应用需要在多个进程间共享数据时，SharedPreferences的默认实现存在严重缺陷：

// 传统SharedPreferences在多进程环境下的问题示例
val sharedPref = getSharedPreferences("my_prefs", Context.MODE_PRIVATE)

// 进程A写入数据
sharedPref.edit().putString("key", "value_from_process_A").apply()

// 进程B读取数据 - 可能读取到旧值或null
val value = sharedPref.getString("key", "default")

问题根源在于：

  1. 无跨进程同步机制：默认仅支持单进程访问
  2. 内存缓存不同步：各进程维护独立内存缓存
  3. 写入延迟问题：apply()异步写入导致同步延迟

解决方案对比

方案 实现难度 性能 可靠性 适用场景
MODE_MULTI_PROCESS ★☆☆ ★★☆ ★☆☆ Android 3.0以下系统
ContentProvider ★★★ ★★☆ ★★★ 需要精细控制的数据共享
MMKV ★☆☆ ★★★ ★★★ 高性能多进程数据共享
文件锁 ★★☆ ★☆☆ ★★☆ 简单键值对同步

解决方案详解

方案1：ContentProvider封装（推荐）

通过ContentProvider实现跨进程数据访问：

class SharedPrefProvider : ContentProvider() {
    
    companion object {
        const val AUTHORITY = "com.example.provider.sharedpref"
        val CONTENT_URI = Uri.parse("content://$AUTHORITY/prefs")
    }
    
    private lateinit var sharedPref: SharedPreferences
    
    override fun onCreate(): Boolean {
        sharedPref = context!!.getSharedPreferences(
            "multi_process_prefs", 
            Context.MODE_PRIVATE
        )
        return true
    }
    
    override fun insert(uri: Uri, values: ContentValues?): Uri? {
        values?.let {
            val key = it.getAsString("key")
            val value = it.getAsString("value")
            sharedPref.edit().putString(key, value).commit()
        }
        return uri
    }
    
    override fun query(
        uri: Uri, 
        projection: Array<String>?, 
        selection: String?, 
        selectionArgs: Array<String>?, 
        sortOrder: String?
    ): Cursor? {
        val key = selectionArgs?.getOrNull(0) ?: return null
        val value = sharedPref.getString(key, null) ?: return null
        
        return MatrixCursor(arrayOf("value")).apply {
            addRow(arrayOf(value))
        }
    }
    
    // 更新数据实现
    override fun update(
        uri: Uri,
        values: ContentValues?,
        selection: String?,
        selectionArgs: Array<String>?
    ): Int {
        values?.let {
            val key = it.getAsString("key")
            val newValue = it.getAsString("value")
            sharedPref.edit().putString(key, newValue).commit()
            return 1
        }
        return 0
    }
    
    // 删除数据实现
    override fun delete(uri: Uri, selection: String?, selectionArgs: Array<String>?): Int {
        selectionArgs?.getOrNull(0)?.let { key ->
            if (sharedPref.contains(key)) {
                sharedPref.edit().remove(key).commit()
                return 1
            }
        }
        return 0
    }
    
    override fun getType(uri: Uri): String? = null
}

注册ContentProvider：

<application>
    <provider
        android:name=".SharedPrefProvider"
        android:authorities="com.example.provider.sharedpref"
        android:exported="true"
        android:process=":remote" />
</application>

跨进程读写操作：

// 写入数据
fun saveData(key: String, value: String) {
    val values = ContentValues().apply {
        put("key", key)
        put("value", value)
    }
    context.contentResolver.insert(SharedPrefProvider.CONTENT_URI, values)
}

// 读取数据
fun getData(key: String): String? {
    return try {
        val cursor = context.contentResolver.query(
            SharedPrefProvider.CONTENT_URI,
            null,
            "key = ?",
            arrayOf(key),
            null
        )
        cursor?.use {
            if (it.moveToFirst()) {
                it.getString(it.getColumnIndex("value"))
            } else null
        }
    } catch (e: Exception) {
        null
    }
}

方案2：MMKV高效解决方案（强烈推荐）

腾讯开源的MMKV是解决多进程数据共享的最佳方案：

添加依赖：

dependencies {
    implementation 'com.tencent:mmkv:1.3.4'
}

初始化：

class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()
        val rootDir = MMKV.initialize(this)
        Log.i("MMKV", "初始化路径: $rootDir")
    }
}

多进程读写操作：

// 获取MMKV实例（多进程模式）
private val kv: MMKV by lazy {
    MMKV.mmkvWithID("inter_process_kv", MMKV.MULTI_PROCESS_MODE)
}

// 写入数据
fun saveUserInfo(user: User) {
    kv.encode("user_name", user.name)
    kv.encode("user_age", user.age)
    kv.encode("user_vip", user.isVip)
}

// 读取数据
fun getUserInfo(): User? {
    return if (kv.contains("user_name")) {
        User(
            name = kv.decodeString("user_name") ?: "",
            age = kv.decodeInt("user_age", 0),
            isVip = kv.decodeBool("user_vip", false)
        )
    } else null
}

// 删除数据
fun clearUserInfo() {
    kv.remove("user_name")
    kv.remove("user_age")
    kv.remove("user_vip")
}

方案3：文件锁同步方案

对于简单场景，可以使用文件锁实现基本同步：

class FileLockHelper(context: Context) {
    private val lockFile = File(context.filesDir, "prefs_lock")
    private val channel by lazy { 
        RandomAccessFile(lockFile, "rw").channel 
    }
    
    @Synchronized
    fun <T> withLock(block: () -> T): T {
        val lock = channel.lock()
        return try {
            block()
        } finally {
            lock.release()
        }
    }
}

// 使用示例
val lockHelper = FileLockHelper(context)

fun saveData(key: String, value: String) {
    lockHelper.withLock {
        val prefs = getSharedPreferences("locked_prefs", MODE_PRIVATE)
        prefs.edit().putString(key, value).commit()
    }
}

fun getData(key: String): String? {
    return lockHelper.withLock {
        val prefs = getSharedPreferences("locked_prefs", MODE_PRIVATE)
        prefs.getString(key, null)
    }
}

方案对比与选型建议
简单键值对
复杂数据结构
临时同步需求
多进程数据共享需求
数据类型
MMKV
ContentProvider
文件锁
高性能
灵活性高
实现简单

选型建议：

  1. 首选MMKV：性能最优，API简单，支持复杂数据类型
  2. 次选ContentProvider：适合需要精细控制数据访问的场景
  3. 避免使用MODE_MULTI_PROCESS：官方已废弃，高版本不可靠

性能优化建议

  1. 批量写入优化：
// MMKV批量写入示例
kv.edit().apply {
    putString("name", "John")
    putInt("age", 30)
    putBoolean("vip", true)
    commit()
}
  1. 数据压缩策略：
// 存储JSON等结构化数据
val userJson = Gson().toJson(user)
kv.encode("user_data", userJson)

// 读取时
val json = kv.decodeString("user_data")
val user = Gson().fromJson(json, User::class.java)
  1. 敏感数据加密：
// 使用MMKV加密敏感数据
val cryptKey = "MySecretKey01".toByteArray()
val secureKV = MMKV.mmkvWithID("secure_kv", 
    MMKV.MULTI_PROCESS_MODE, 
    cryptKey)

关键点总结

  1. 避免使用SharedPreferences：在多进程环境中完全避免直接使用SharedPreferences
  2. 优先选择MMKV：腾讯MMKV是最佳的多进程数据共享解决方案
  3. ContentProvider适用场景：需要精细控制数据访问逻辑时使用
  4. 性能优先原则：减少跨进程通信频率，批量处理数据
  5. 数据一致性保障：使用同步写入（commit）替代异步写入（apply）
  6. 安全考虑：对敏感数据使用加密存储

进阶扩展

使用DataStore替代SharedPreferences

Jetpack DataStore是Google推荐的SharedPreferences替代方案：

dependencies {
    implementation "androidx.datastore:datastore-preferences:1.0.0"
}

// 创建DataStore
val Context.dataStore by preferencesDataStore(name = "settings")

// 写入数据
suspend fun saveSettings(isDarkMode: Boolean) {
    context.dataStore.edit { preferences ->
        preferences[PreferencesKeys.booleanKey("dark_mode")] = isDarkMode
    }
}

// 读取数据
val darkModeFlow: Flow<Boolean> = context.dataStore.data
    .map { preferences ->
        preferences[PreferencesKeys.booleanKey("dark_mode")] ?: false
    }

注意：DataStore目前不支持多进程，但可以结合本文方案实现多进程同步

多进程数据同步流程图

进程A MMKV 进程B 文件系统 写入数据(key, value) 更新内存缓存 同步写入磁盘 写入完成 读取数据(key) 检查内存缓存 返回缓存值 从磁盘读取 更新缓存 返回读取值 alt [数据在缓存中] [数据不在缓存中] 进程A MMKV 进程B 文件系统

结语

在多进程Android应用中，SharedPreferences已不再是数据共享的最佳选择。本文介绍的MMKV和ContentProvider方案提供了更可靠、高效的解决方案。建议开发者根据具体场景选择合适的技术方案：

  1. 对于高性能需求，优先选择MMKV
  2. 对于复杂数据管理，使用ContentProvider
  3. 对于简单同步需求，可考虑文件锁方案

通过合理选择技术方案，开发者可以彻底解决Android多进程数据共享的难题，构建更稳定高效的应用程序。

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布