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

好的，以下是Kotlin代码实现：

Task.kt

data class Task(val clientId: String, val taskType: String, val priority: Int, val task: Runnable)

TaskStack.kt

import java.util.*
import java.util.concurrent.locks.ReentrantLock

class TaskStack {
    private val lock = ReentrantLock()
    private val taskQueue: Queue<Task> = PriorityQueue(Comparator<Task> { t1, t2 -> t1.priority - t2.priority })

    fun addTask(task: Task) {
        lock.lock()
        taskQueue.add(task)
        lock.unlock()
    }

    fun getTask(): Task? {
        lock.lock()
        val task = taskQueue.poll()
        lock.unlock()
        return task
    }
}

Dispatcher.kt

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

class Dispatcher {
    private val executorService: ExecutorService = Executors.newCachedThreadPool()

    fun dispatchTask(task: Task, callback: Callback) {
        val runnable = Runnable {
            val result = task.task.run()
            callback.onResult(task.clientId, task.taskType, result)
        }
        if (task.priority == TaskPriority.HIGH) {
            executorService.execute(runnable)
        } else {
            runnable.run()
        }
    }

    interface Callback {
        fun onResult(clientId: String, taskType: String, result: Any)
    }
}

TaskPriority.kt

object TaskPriority {
    const val LOW = 0
    const val HIGH = 1
}

TaskHandler.kt

import android.os.Handler
import android.os.IBinder
import android.os.RemoteException

class TaskHandler(private val taskStack: TaskStack) : ITaskHandler.Stub() {
    private val dispatch = Dispatcher()

    override fun addTask(clientId: String, taskType: String, priority: Int, task: ITask): Boolean {
        val runnable = Runnable {
            try {
                task.run()
            } catch (e: RemoteException) {
                e.printStackTrace()
            }
        }
        taskStack.addTask(Task(clientId, taskType, priority, runnable))
        return true
    }

    override fun registerCallback(clientId: String, taskType: String, callback: ITaskCallback) {
        // TODO: 将callback注册到任务和任务结果的映射表中
    }

    override fun unregisterCallback(clientId: String, taskType: String) {
        // TODO: 从任务和任务结果的映射表中移除callback
    }

    fun start() {
        Thread {
            while (true) {
                val task = taskStack.getTask()
                if (task == null) {
                    Thread.sleep(1000)
                    continue
                }
                val callback = getCallback(task.clientId, task.taskType)
                dispatch.dispatchTask(task, object : Dispatcher.Callback {
                    override fun onResult(clientId: String, taskType: String, result: Any) {
                        try {
                            callback?.onResult(result)
                        } catch (e: RemoteException) {
                            e.printStackTrace()
                        }
                    }
                })
            }
        }.start()
    }

    private fun getCallback(clientId: String, taskType: String): ITaskCallback? {
        // TODO: 从任务和任务结果的映射表中获取callback
        return null
    }
}

ITaskHandler.aidl

interface ITaskHandler {
    boolean addTask(in String clientId, in String taskType, in int priority, in ITask task);
    void registerCallback(in String clientId, in String taskType, in ITaskCallback callback);
    void unregisterCallback(in String clientId, in String taskType);
}

ITask.aidl

interface ITask {
    void run();
}

ITaskCallback.aidl

interface ITaskCallback {
    void onResult(in Object result);
}