阻塞式读取，调用 close()，子线程任然活跃，实际上已经内存泄漏！

[z1476639-sys]

private val serialReadRunnable = Runnable {
val buffer = ByteArray(1024)

    while (!Thread.currentThread().isInterrupted) {

        val isRunning = synchronized(lock) { running }
        if (!isRunning) break
        try {
            val available = inputStream?.available()?.coerceAtMost(buffer.size) ?: 0
            if (available > 0) {
                val newData = ByteArray(available)
                val size = inputStream?.read(newData, 0, available) ?: 0
                if (size > 0) {
                    synchronized(lock) {
                        outputBuffer.addAll(newData.toList())
                    }

                    sendHandler.sendEmptyMessage(2)
                }
            } else {
                val byte = inputStream?.read()
                if (byte != null && byte != -1) {
                    synchronized(lock) {
                        outputBuffer.add(byte.toByte())
                    }

                    sendHandler.sendEmptyMessage(2)
                }
            }
        } catch (e: Exception) {
            // fun open()  Cannot capture exception here

            Log.e(TAG, "$TAG serialReadRunnableError:", e)
            break
        }

    }

}

fun close() {

    synchronized(lock) {
        if (!running) return
        running = false
        removeScanListener()

        outputStream?.close()
        inputStream?.close()

        serialPort?.close()

        readHandler.removeCallbacksAndMessages(null)
        sendHandler.removeCallbacksAndMessages(null)


        readThread?.interrupt()
        sendThread?.interrupt()

        readThread?.let {
            it.quitSafely()
            it.join(5000)
            if (it.isAlive) {
                Log.e(TAG, "readThread.isAlive ")
            } else {
                readThread = null
                Log.e(TAG, "close: readThread= null")
            }
        }

        sendThread?.let {
            it.quitSafely()
            it.join(1000)
            if (it.isAlive) {
                Log.e(TAG, "sendThread.isAlive ")
            } else {
                sendThread = null
                Log.e(TAG, "close: sendThread = null")
            }
        }

        val alive = readThread?.isAlive
        if (alive == true) {
            Log.e(TAG, "close: 1111")
        }

        val alive2 = sendThread?.isAlive
        if (alive2 == true) {
            Log.e(TAG, "close: 2222")
        }
        synchronized(lock) {
            outputBuffer.clear()
        }

        serialPort = null
        inputStream = null
        outputStream = null
        readThread = null
        sendThread = null
    }
}

这样阻塞式读取，调用 close()，子线程任然活跃，实际上已经内存泄漏！