Mina2.0框架源码剖析（八）

这篇来看看AbstractPollingIoConnector抽象类，它用于用于实现客户端连接的轮询策略。处理逻辑基本上和上一篇文章说的AbstractPollingIoAcceptor类似，它继承自AbstractIoConnector，两个泛型参数分别是所处理的会话和客户端socket连接。底层的sockets会被不断检测，并当有任何一个socket需要被处理时就会被唤醒去处理。这个类封装了客户端socket的bind,connect和dispose等动作，其成员变量Executor用于发起连接请求，另一个AbstractPollingIoProcessor用于处理已经连接客户端的I/O操作请求，如读写和关闭连接。

其最重要的几个成员变量是：

private final Queue<ConnectionRequest> connectQueue = new ConcurrentLinkedQueue<ConnectionRequest>();//连接队列
private final Queue<ConnectionRequest> cancelQueue = new ConcurrentLinkedQueue<ConnectionRequest>();// 取消连接队列

先来看看当服务端调用connect后的处理过程：

    protected final ConnectFuture connect0(
            SocketAddress remoteAddress, SocketAddress localAddress,
            IoSessionInitializer<? extends ConnectFuture> sessionInitializer) {
        H handle = null;
        boolean success = false;
        try {
            handle = newHandle(localAddress);
            if (connect(handle, remoteAddress)) {//若已经连接服务器成功
                ConnectFuture future = new DefaultConnectFuture();
                T session = newSession(processor, handle);//创建新会话
                finishSessionInitialization(session, future, sessionInitializer);//结束会话初始化
                session.getProcessor().add(session);//将剩下的处理交给IoProcessor
                success = true;
                return future;
            }
            success = true;
        } catch (Exception e) {
            return DefaultConnectFuture.newFailedFuture(e);
        } finally {
            if (!success && handle != null) {
                try {
                    close(handle);
                } catch (Exception e) {
                    ExceptionMonitor.getInstance().exceptionCaught(e);
                }
            }
        }
        ConnectionRequest request = new ConnectionRequest(handle, sessionInitializer);
        connectQueue.add(request);//连接请求加入连接队列中
        startupWorker();//开启工作线程处理连接请求
        wakeup();//中断select操作
        return request;
    }

     真正的负责处理客户端请求的工作都是Worker线程完成的,

private class Worker implements Runnable {
        public void run() {
            int nHandles = 0;
            while (selectable) {
                try {
                      int timeout = (int)Math.min(getConnectTimeoutMillis(), 1000L);//等待超时时间
                    boolean selected = select(timeout);//在超时时限内查看是否有可以被处理的选择键（状态
                    nHandles += registerNew();//取出连接队列队头的连接请求，将其注册一个用于连接的新的客户端socket， 并把它加入连接轮询池中
                    if (selected) {
                        nHandles-= processSessions(selectedHandles());//处理连接请求
                    }
                    processTimedOutSessions(allHandles());//处理超时连接请求
                    nHandles -= cancelKeys();
                    if (nHandles == 0) {
                        synchronized (lock) {
                            if (connectQueue.isEmpty()) {
                                worker = null;
                                break;
                            }
                        }
                    }
                } catch (Throwable e) {
                    ExceptionMonitor.getInstance().exceptionCaught(e);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e1) {
                        ExceptionMonitor.getInstance().exceptionCaught(e1);
                    }
                }
            }
            if (selectable && isDisposing()) {
                selectable = false;
                try {
                    if (createdProcessor) {
                        processor.dispose();
                    }
                } finally {
                    try {
                        synchronized (disposalLock) {
                            if (isDisposing()) {
                                destroy();
                            }
                        }
                    } catch (Exception e) {
                        ExceptionMonitor.getInstance().exceptionCaught(e);
                    } finally {
                        disposalFuture.setDone();
                    }
                }
            }
        }
    }
private int registerNew() {
        int nHandles = 0;
        for (; ;) {
            ConnectionRequest req = connectQueue.poll();//取连接队列队头请求
            if (req == null) {
                break;
            }
            H handle = req.handle;
            try {
                register(handle, req);//注册一个用于连接的新的客户端socket， 并把它加入连接轮询池中
                nHandles ++;
            } catch (Exception e) {
                req.setException(e);
                try {
                    close(handle);
                } catch (Exception e2) {
                    ExceptionMonitor.getInstance().exceptionCaught(e2);
                }
            }
        }
        return nHandles;
    }
private int processSessions(Iterator<H> handlers) {//处理连接请求
        int nHandles = 0;
        while (handlers.hasNext()) {
            H handle = handlers.next();
            handlers.remove();
            ConnectionRequest entry = connectionRequest(handle);
            boolean success = false;
            try {
                if (finishConnect(handle)) {//连接请求成功完成，创建一个新会话
                    T session = newSession(processor, handle);
                    finishSessionInitialization(session, entry, entry.getSessionInitializer());//结束会话初始化
                    session.getProcessor().add(session);//将剩下的工作交给IoProcessor去处理
                    nHandles ++;
                }
                success = true;
            } catch (Throwable e) {
                entry.setException(e);
            } finally {
                if (!success) {//若连接失败，则将此连接请求放到取消连接队列中
                    cancelQueue.offer(entry);
                }
            }
        }
        return nHandles;
    }
private void processTimedOutSessions(Iterator<H> handles) {//处理超时的连接请求
        long currentTime = System.currentTimeMillis();//当前时间

        while (handles.hasNext()) {
            H handle = handles.next();
            ConnectionRequest entry = connectionRequest(handle);
            if (currentTime >= entry.deadline) {//当前时间已经超出了连接请求的底限
                entry.setException(
                        new ConnectException("Connection timed out."));
                cancelQueue.offer(entry);//将此连接请求放入取消连接队列中
            }
        }
    }
private int cancelKeys() {//把取消队列中的连接请求给cancel掉
        int nHandles = 0;
        for (; ;) {
            ConnectionRequest req = cancelQueue.poll();
            if (req == null) {
                break;
            }
            H handle = req.handle;
            try {
                close(handle);//关闭对应的客户端socket
            } catch (Exception e) {
                ExceptionMonitor.getInstance().exceptionCaught(e);
            } finally {
                nHandles ++;
            }
        }
        return nHandles;
    }

 

作者：phinecos(洞庭散人)
出处：http://phinecos.cnblogs.com/
本文版权归作者和博客园共有，欢迎转载，但请保留此段声明，并在文章页面明显位置给出原文连接。