tomcat 源码研究之servlet单例多线程模式

一， tomcat 处理请求的组件 Engine Host Context 和 Wrapper 这四个 分别对应的实现类StnadardEngine，StandardHost，StandardContext和StandardWrapper
Engine：代表tomcat的引擎，可以有多个引擎，他与Connector连接器并列 起到请求与虚拟机主机下对应应用程序的定位。
Host：代表一个虚拟主机，各Host的name不能相同，appBase代表各虚拟主机的应用发布位置；
Context：代表一个应用，Context可以根据应用的/WEB-INF/web.xml文件中定义的servlet来处理请求。一个Host下可以有多个Context；
Wrapper： 代表一个Servlet或者jsp，它负责管理一个 Servlet，包括的 Servlet 的装载、初始化、执行以及资源回收。
二，请求在这些容器之间的流转又是通过管道Pipeline 管道是由他们父类容器ContainerBase来控制的， 而管道中流转的是Value这样的东西，而每个容器的都实现了自己的值分别是StandardEngineValue，StandardHostValue，
     StandardContextValue和StandardWrapperValue


下面请看从配适器CoyoteAdapter中已经 初步封装的请求 ，如图Service方法

      public void service(org.apache.coyote.Request req,
                        org.apache.coyote.Response res)
        throws Exception {
        Request request = (Request) req.getNote(ADAPTER_NOTES);
        Response response = (Response) res.getNote(ADAPTER_NOTES);
        if (request == null) {
            // Create objects
            request = connector.createRequest();
            request.setCoyoteRequest(req);
            response = connector.createResponse();
            response.setCoyoteResponse(res);
            // Link objects
            request.setResponse(response);
            response.setRequest(request);
            // Set as notes
            req.setNote(ADAPTER_NOTES, request);
            res.setNote(ADAPTER_NOTES, response);
            // Set query string encoding
            req.getParameters().setQueryStringEncoding
                (connector.getURIEncoding());
        }

        if (connector.getXpoweredBy()) {
            response.addHeader("X-Powered-By", POWERED_BY);
        }
        boolean comet = false;
        boolean async = false;
        try {

            // Parse and set Catalina and configuration specific
            // request parameters           req.getRequestProcessor().setWorkerThreadName(Thread.currentThread().getName());
            boolean postParseSuccess = postParseRequest(req, request, res, response);
            if (postParseSuccess) {
                //check valves if we support async
                request.setAsyncSupported(connector.getService().getContainer().getPipeline().isAsyncSupported());
                // Calling the container的first其实就是StandardEngineValve这么一个类
                connector.getService().getContainer().getPipeline().getFirst().invoke(request, response);
//代码省略

重点看这句话代码

 connector.getService().getContainer().getPipeline().getFirst().invoke(xxx,xxx)

由于connector找到父类Service容器 然后找到处理请求的一组容器的顶级容器 即Engine 这个容器管道 此管道中流转的就是StandardEngineValue这样的即getFirst（）方法调用得到
交给此Value值处理（invoke）

下面是 StandardEngineValue方法中invoke

      @Override
    public final void invoke(Request request, Response response)
        throws IOException, ServletException {

        // Select the Host to be used for this Request
        Host host = request.getHost();
        if (host == null) {
            response.sendError
                (HttpServletResponse.SC_BAD_REQUEST,
                 sm.getString("standardEngine.noHost", 
                              request.getServerName()));
            return;
        }
        if (request.isAsyncSupported()) {
            request.setAsyncSupported(host.getPipeline().isAsyncSupported());
        }

        // Ask this Host to process this request
        host.getPipeline().getFirst().invoke(request, response);

    }

也是用了同样的代码

  host.getPipeline().getFirst().invoke(request, response);

继续StandardHostValue 一直到 StandardWrapperValue的invoke方法

  @Override
    public final void invoke(Request request, Response response)
        throws IOException, ServletException {

        // Initialize local variables we may need
        boolean unavailable = false;
        Throwable throwable = null;
        // This should be a Request attribute...
        long t1=System.currentTimeMillis();
        requestCount++;
        StandardWrapper wrapper = (StandardWrapper) getContainer();
        Servlet servlet = null;
        Context context = (Context) wrapper.getParent();
        
        // Check for the application being marked unavailable
        if (!context.getState().isAvailable()) {
            response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE,
                           sm.getString("standardContext.isUnavailable"));
            unavailable = true;
        }

        // Check for the servlet being marked unavailable
        if (!unavailable && wrapper.isUnavailable()) {
            container.getLogger().info(sm.getString("standardWrapper.isUnavailable",
                    wrapper.getName()));
            long available = wrapper.getAvailable();
            if ((available > 0L) && (available < Long.MAX_VALUE)) {
                response.setDateHeader("Retry-After", available);
                response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE,
                        sm.getString("standardWrapper.isUnavailable",
                                wrapper.getName()));
            } else if (available == Long.MAX_VALUE) {
                response.sendError(HttpServletResponse.SC_NOT_FOUND,
                        sm.getString("standardWrapper.notFound",
                                wrapper.getName()));
            }
            unavailable = true;
        }

        // Allocate a servlet instance to process this request
        try {
            if (!unavailable) {
            	//加载实例化Servlet实例 （init（ServletConfig config）方法也被初始化了）
            	//可以看出Servlet是单例的
                servlet = wrapper.allocate();
            }
// 省略代码 ...

接着StandardWrapper的allocate()的方法 查看servlet的创建过程
代码如下

  public Servlet allocate() throws ServletException {

        // If we are currently unloading this servlet, throw an exception
        if (unloading)
            throw new ServletException
              (sm.getString("standardWrapper.unloading", getName()));

        boolean newInstance = false;
        
        // If not SingleThreadedModel, return the same instance every time
        if (!singleThreadModel) {

            // Load and initialize our instance if necessary
            if (instance == null) {
                synchronized (this) {
                    if (instance == null) {
                        try {
                            if (log.isDebugEnabled())
                                log.debug("Allocating non-STM instance");

                            instance = loadServlet();
                            if (!singleThreadModel) {
                                // For non-STM, increment here to prevent a race
                                // condition with unload. Bug 43683, test case
                                // #3
                                newInstance = true;
                                countAllocated.incrementAndGet();
                            }
                        } catch (ServletException e) {
                            throw e;
                        } catch (Throwable e) {
                            ExceptionUtils.handleThrowable(e);
                            throw new ServletException
                                (sm.getString("standardWrapper.allocate"), e);
                        }
                    }
                }
            }

            if (!instanceInitialized) {
            	//实例化Servlet
                initServlet(instance);
            }

            if (singleThreadModel) {
                if (newInstance) {
                    // Have to do this outside of the sync above to prevent a
                    // possible deadlock
                    synchronized (instancePool) {
                        instancePool.push(instance);
                        nInstances++;
                    }
                }
            } else {
                if (log.isTraceEnabled())
                    log.trace("  Returning non-STM instance");
                // For new instances, count will have been incremented at the
                // time of creation
                if (!newInstance) {
                    countAllocated.incrementAndGet();
                }
                return (instance);
            }
        }

        synchronized (instancePool) {

            while (countAllocated.get() >= nInstances) {
                // Allocate a new instance if possible, or else wait
                if (nInstances < maxInstances) {
                    try {
                        instancePool.push(loadServlet());
                        nInstances++;
                    } catch (ServletException e) {
                        throw e;
                    } catch (Throwable e) {
                        ExceptionUtils.handleThrowable(e);
                        throw new ServletException
                            (sm.getString("standardWrapper.allocate"), e);
                    }
                } else {
                    try {
                        instancePool.wait();
                    } catch (InterruptedException e) {
                        // Ignore
                    }
                }
            }
            if (log.isTraceEnabled())
                log.trace("  Returning allocated STM instance");
            countAllocated.incrementAndGet();
            return instancePool.pop();

        }

    }

上述代码可知
1，对于没有实现SingleThreadModel 会确保只有一个instance实例 也就是单个servlet实例
即每次请求都访问同一servlet
2，　如果servlet实现了该接口，会确保不会有两个线程同时执行servlet的service方法。 servlet容器通过同步化访问servlet的单实例来保证，也可以通过维持servlet的实例池，对于新的请求会分配给一个空闲的servlet。
3，注意：SingleThreadModel不会解决所有的线程安全隐患。 例如，会话属性和静态变量仍然可以被多线程的多请求同时访问，即便使用了SingleThreadModel servlet。建议开发人员应当采取其他手段来解决这些问题，而不是实现该接口，比如 避免实例变量的使用或者在访问资源时同步代码块。