mina实现相同session后到的请求一定后处理的原理

mina后面的业务处理是一个线程池去处理的，在线程池的多线程的情况下，一般是不能保证后面的请求一定后处理的。因为可能后面的线程处理更快。
mina是怎么做到的呢：
基本原理是 每个session有个自己的queue，而且相同这个queue的元素一定在同一个线程处理

具体原理：
mina使用的是OrderedThreadPoolExecutor，具体的处理是Worker

for (;;) {
                    IoSession session = fetchSession();

                    idleWorkers.decrementAndGet();

                    if (session == null) {
                        synchronized (workers) {
                            if (workers.size() > getCorePoolSize()) {
                                // Remove now to prevent duplicate exit.
                                workers.remove(this);
                                break;
                            }
                        }
                    }

                    if (session == EXIT_SIGNAL) {
                        break;
                    }

                    try {
                        if (session != null) {
                            runTasks(getSessionTasksQueue(session));
                        }
                    } finally {
                        idleWorkers.incrementAndGet();
                    }
                }

IoSession session = fetchSession();  拿到session
  runTasks(getSessionTasksQueue(session));  运行session对应queue的任务

 private void runTasks(SessionTasksQueue sessionTasksQueue) {
            for (;;) {
                Runnable task;
                Queue<Runnable> tasksQueue = sessionTasksQueue.tasksQueue;
                
                synchronized (tasksQueue) {
                    task = tasksQueue.poll();
                    
                    if (task == null) {
                        sessionTasksQueue.processingCompleted = true;
                        break;
                    }
                }

                eventQueueHandler.polled(OrderedThreadPoolExecutor.this, (IoEvent) task);

                runTask(task);
            }
        }

synchronized (tasksQueue)  可以看到执行任务的时候是锁住sesssion的queue的，这个时候是不能添加任务的，所以可以保证同一个queue的任务是在同一个线程执行的，
（ps：worker 可以理解为一个线程）