Tomcat的Socket实现：org.apache.tomcat.util.net（一）

org.apache.tomcat.util.net包的内容都与网络连接和socket有关，比较主要和常见的是JIOEndpoint这个类，前面提到Coyote连接器的时候，就有涉及到JIOEndpoint，它用于监听某个socket端口、将socket对象交给coyote，并提供基本的线程池功能。除了JIOEndpoint，还有AprEndpoint、NioEndpoint等。由于对apr和nio不熟悉，所以只研究了一下JIOEndpoint

org.apache.tomcat.util.net.JIoEndpoint
JIOEndpoint其实和我们本科时上计算机网络或者分布式系统，做实验写的socket服务器差不多，结构也是经典的“Listen-Accept-Handle”，这里简单描述一下：JIOEndpoint使用JDK的ServerSocket类监听某个端口，有socket连接进来的时候便返回一个socket对象，交给专门的处理器。当然，具体的实现没那么简单，下面会按照socket的处理过程，详细说明其中的机理。

初始化
public void init()
        throws Exception {

        if (initialized)
            return;
        // Initialize thread count defaults for acceptor
        if (acceptorThreadCount == 0) {
            acceptorThreadCount = 1;
        }
        if (serverSocketFactory == null) {
            serverSocketFactory = ServerSocketFactory.getDefault();
        }
        if (serverSocket == null) {
            try {
                if (address == null) {
                    serverSocket = serverSocketFactory.createSocket(port, backlog);
                } else {
                    serverSocket = serverSocketFactory.createSocket(port, backlog, address);
                }
            } catch (BindException be) {
                throw new BindException(be.getMessage() + ":" + port);
            }
        }
        //if( serverTimeout >= 0 )
        //    serverSocket.setSoTimeout( serverTimeout );
        initialized = true;
    }

在这里，利用serverSocketFactory新建了一个serverSocket对象，用于监听特定的端口

启动JIOEndpoint
// Create worker collection
            if (executor == null) {
                workers = new WorkerStack(maxThreads);
            }

            // Start acceptor threads
            for (int i = 0; i < acceptorThreadCount; i++) {
                Thread acceptorThread = new Thread(new Acceptor(), getName() + "-Acceptor-" + i);
                acceptorThread.setPriority(threadPriority);
                acceptorThread.setDaemon(daemon);
                acceptorThread.start();
            }

这里有几个类：worker，workerStack，Acceptor。这些都是JIOEndpoint的一些内部类，下面按照处理顺序依次讲述

Acceptor内部类
Acceptor实现了Runnable接口，只有一个方法run，做的事情就是通过ServerSocket.accept方法，得到socket，然后调用JIOEndpoint的processSocket方法

protected boolean processSocket(Socket socket) {
        try {
            if (executor == null) {
                getWorkerThread().assign(socket);
            } else {
                executor.execute(new SocketProcessor(socket));
            }
        } catch (Throwable t) {
            // This means we got an OOM or similar creating a thread, or that
            // the pool and its queue are full
            log.error(sm.getString("endpoint.process.fail"), t);
            return false;
        }
        return true;
    }

在这里，JIOEndpoint有两种处理socket的方式：使用JDK5的executor，或者内部的worker类。executor怎么用大家可以直接翻书了，我们继续讨论第二种方法。

首先我们要通过getWorkerThread()方法，得到一个Worker对象。具体逻辑是，看看WorkerStack（存放所有worker的一个堆栈）里面有没有空余的worker，有则直接拿来用，无则看看能不能新建一个worker线程，假如不能（比如超出了最大线程数限制），则返回null，那样就只能委屈一下这个acceptor，稍微等一下了（wait()方法），直到有新的worker可用时，通过notify方法唤醒等待的acceptor

     /**
     * Return a new worker thread, and block while to worker is available.
     */
    protected Worker getWorkerThread() {
        // Allocate a new worker thread
        Worker workerThread = createWorkerThread();
        while (workerThread == null) {
            try {
                synchronized (workers) {
                    workers.wait();
                }
            } catch (InterruptedException e) {
                // Ignore
            }
            workerThread = createWorkerThread();
        }
        return workerThread;
    }

如下，当有worker被回收后，通知等待的acceptor

protected void recycleWorkerThread(Worker workerThread) {
        synchronized (workers) {
            workers.push(workerThread);
            curThreadsBusy--;
            workers.notify();
        }
    }



ok，回到前面的processSocket方法，得到worker后，通过worker.assign方法，将socket对象传递给worker

Worker内部类
Worker也实现了runnable接口，有三个方法：assign、await、start和run

所谓的start方法，就是new一个Thread对象，把worker自己传进去，我们知道这个thread就开始执行run方法了。

public void run() {

            // Process requests until we receive a shutdown signal
            while (running) {

                // Wait for the next socket to be assigned
                Socket socket = await();
                if (socket == null)
                    continue;

                // Process the request from this socket
                if (!setSocketOptions(socket) || !handler.process(socket)) {
                    // Close socket
                    try {
                        socket.close();
                    } catch (IOException e) {
                    }
                }

                // Finish up this request
                socket = null;
                recycleWorkerThread(this);

            }

        }

run方法首先调用await方法

private synchronized Socket await() {

            // Wait for the Connector to provide a new Socket
            while (!available) {
                try {
                    wait();
                } catch (InterruptedException e) {
                }
            }

            // Notify the Connector that we have received this Socket
            Socket socket = this.socket;
            available = false;
           notifyAll();

            return (socket);

        }

通过标记位available，如果当前的worker是“非available”的，则线程会开始等待。直到我们调用的assign方法，把一个可用的socket给worker后，才会notifyall，唤醒一个线程，进而取得assign过来的socekt

synchronized void assign(Socket socket) {

            // Wait for the Processor to get the previous Socket
            while (available) {
                try {
                    wait();
                } catch (InterruptedException e) {
                }
            }

            // Store the newly available Socket and notify our thread
            this.socket = socket;
            available = true;
            notifyAll();

        }

所以，assign和await方法相当于生产者和消费者方法，两者通过available进行互斥，而this.socket则相当于被竞争的资源

现在，又回到Worker.run方法。在取得socket后，通过setSocketOptions(socket)方法设置socket的相关选项（例如超时值），最后通过handler.process(socket)，终于把socket这个接力棒交给coyote了！

handler是什么？就是个简单的接口，如下：

/**
     * Bare bones interface used for socket processing. Per thread data is to be
     * stored in the ThreadWithAttributes extra folders, or alternately in
     * thread local fields.
     */
    public interface Handler {
        public boolean process(Socket socket);
    }

回顾一下org.apache.coyote.http11.Http11Protocol 的Http11ConnectionHandler内部类，实现的正是这个接口