kotlin 代码使用AIDL 技术实现一个服务端可以接收来自多个不同的APP客户端的请求，要区分来自哪一个客户端app的什么类型请求，把请求加入任务栈，任务栈用一个单独的类TaskStack来管理，任务和注册的回调消息绑定。在一个子线程中while循环取出任务栈中的任务，有一个Dispach类来管理任务的分发，在Dispach类中按照请求的优先级同步或者异步的将任务分发执行,还需要考虑任务的优先级、同步或异步处理等问题，执行完成后通过Dispach把消息回调给发请求的那个客户端app，要求线程安全，给出详细的每一个类的代码

Task.kt

data class Task(val clientId: String, val type: String, val priority: Int, val data: Any?)

TaskStack.kt

import java.util.concurrent.LinkedBlockingQueue

class TaskStack {

    private val queue = LinkedBlockingQueue<Task>()

    fun add(task: Task) {
        queue.put(task)
    }

    fun get(): Task? {
        return queue.take()
    }
}

Dispatch.kt

import java.util.concurrent.ExecutorService
import java.util.concurrent.Executors

class Dispatch {

    private val taskStack = TaskStack()
    private val executor: ExecutorService = Executors.newCachedThreadPool()

    fun dispatch() {
        while (true) {
            val task = taskStack.get()
            if (task != null) {
                executeTask(task)
            }
        }
    }

    fun addTask(task: Task) {
        taskStack.add(task)
    }

    private fun executeTask(task: Task) {
        val callback = CallbackManager.getCallback(task.clientId)
        if (callback != null) {
            if (task.type == TaskType.SYNC) {
                val result = task.execute()
                callback.onResult(result)
            } else {
                executor.execute {
                    val result = task.execute()
                    callback.onResult(result)
                }
            }
        }
    }
}

Callback.kt

interface Callback {
    fun onResult(data: Any?)
}

CallbackManager.kt

import java.util.concurrent.ConcurrentHashMap

object CallbackManager {

    private val callbackMap = ConcurrentHashMap<String, Callback>()

    fun registerCallback(clientId: String, callback: Callback) {
        callbackMap[clientId] = callback
    }

    fun getCallback(clientId: String): Callback? {
        return callbackMap[clientId]
    }

    fun unregisterCallback(clientId: String) {
        callbackMap.remove(clientId)
    }
}

TaskPriority.kt

object TaskPriority {
    const val HIGH = 1
    const val NORMAL = 2
}

TaskType.kt

object TaskType {
    const val SYNC = "sync"
    const val ASYNC = "async"
}

使用时，需要在服务端实现 AIDL 接口，通过 Binder 对象调用服务端的方法。在服务端的方法中，先将请求封装成 Task 对象，然后加入任务栈。Dispach 类的 dispatch() 方法在一个子线程中循环取出任务，并根据优先级同步或异步执行任务，执行完成后通过 Callback 回调给客户端。在客户端需要实现 Callback 接口，注册回调，以便接收服务端的结果。CallbackManager 类用来管理 Callback 对象，需要在客户端注册并传递给服务端。