Android Kotlin中synchronized与FileInputStream.read引发线程饥饿警告

问题背景 #

使用synchronized同步文件读写操作以避免并发冲突时，触发了警告：Possibly blocking call in non-blocking context could lead to thread starvation，代码示例如下：

fun read(inputStream: FileInputStream) {
    synchronized(this) {
        // warning: Possibly blocking call in non-blocking context could lead to thread starvation
        var nextByte: Int = inputStream.read()    
    }
}

fun write(outputStream: FileOutputStream, data: ByteArray) {
    synchronized(this) {
        outputStream.write(data)
    }
}

目前无法将代码改写为协程，需要其他可行的解决办法。

可行解决方案 #

1. 用显式锁ReentrantLock替代synchronized #

synchronized属于隐式锁，静态代码分析容易在非阻塞上下文误判其阻塞行为。改用java.util.concurrent.locks.ReentrantLock这种显式锁，既能保证读写互斥的语义，又能避开警告：

import java.util.concurrent.locks.ReentrantLock

private val lock = ReentrantLock()

fun read(inputStream: FileInputStream) {
    lock.lock()
    try {
        var nextByte: Int = inputStream.read()
    } finally {
        // 必须在finally中释放锁，避免异常导致锁泄漏
        lock.unlock()
    }
}

fun write(outputStream: FileOutputStream, data: ByteArray) {
    lock.lock()
    try {
        outputStream.write(data)
    } finally {
        lock.unlock()
    }
}

ReentrantLock和synchronized一样是可重入锁，完全适配读写互斥的场景，你提到的“用锁替代synchronized有效”指的就是这类方案。

2. 将读写操作移至专用阻塞线程池执行 #

如果代码运行在非阻塞上下文（比如协程的Dispatchers.Main或Dispatchers.Default），可以把整个读写逻辑放到专门处理阻塞任务的单线程线程池中，天然保证操作串行化：

import java.util.concurrent.Executors

private val blockingExecutor = Executors.newSingleThreadExecutor()

fun read(inputStream: FileInputStream) {
    blockingExecutor.submit {
        var nextByte: Int = inputStream.read()
    }
}

fun write(outputStream: FileOutputStream, data: ByteArray) {
    blockingExecutor.submit {
        outputStream.write(data)
    }
}

单线程线程池里的任务会按顺序执行，无需额外加锁，所有阻塞操作都在专用线程中处理，不会触发非阻塞上下文的警告。

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