Java Servlet(十一)：一个servlet被10个浏览器客户端访问时会创建几个servlet实例？

一般Servlet只初始化一次（只有一个实例）。对于更多的客户端请求，Server创建新的请求和响应对象，仍然激活此Servlet的service（）方法，将这两个对象作为参数传递给该方法。如此重复以上的循环，但无需再调用init（）方法。

原因：

出于性能的考虑：特别的对于门户网站而言，每一个Servlet在每一秒内的并发访问量都可以是成千上万的。在一个面向模块化开发的现在，常常一个点击操作就被定义为一个Servlet的实现，而如果Servlet的每一次被访问，都创建一个新的实例的话，服务器的可用资源消耗量将是一个相当重要的问题。
退一步，一般Servlet的访问是很快的，每一个实例被快速的创建，又被快速的回收，GC的回收速度也跟不上，频繁的内存操作也将可能带来次生的问题。

所以，Servlet的“单一实例化”是一个很重要的策略。

此时为了更好理解servlet，这里附上servlet、httpservlet代码：

Servlet源代码：

package javax.servlet;  
import java.io.IOException;  
// Referenced classes of package javax.servlet:  
// ServletException, ServletConfig, ServletRequest, ServletResponse  
public interface Servlet  
{  
    public abstract void init(ServletConfig servletconfig)  
        throws ServletException;  
    public abstract ServletConfig getServletConfig();  
    public abstract void service(ServletRequest servletrequest, ServletResponse servletresponse)  
        throws ServletException, IOException;  
    public abstract String getServletInfo();  
    public abstract void destroy();  
}  

HttpServlet源代码：

import java.io.IOException;  
import java.io.Serializable;  
import java.lang.reflect.Method;  
import java.text.MessageFormat;  
import java.util.Enumeration;  
import java.util.ResourceBundle;  
import javax.servlet.*;  
// Referenced classes of package javax.servlet.http:  
//            NoBodyResponse, HttpServletRequest, HttpServletResponse  
public abstract class HttpServlet extends GenericServlet  
    implements Serializable  
{  
    public HttpServlet()  
    {  
    }  
    protected void doGet(HttpServletRequest req, HttpServletResponse resp)  
        throws ServletException, IOException  
    {  
        String protocol = req.getProtocol();  
        String msg = lStrings.getString("http.method_get_not_supported");  
        if(protocol.endsWith("1.1"))  
            resp.sendError(405, msg);  
        else  
            resp.sendError(400, msg);  
    }  
    protected long getLastModified(HttpServletRequest req)  
    {  
        return -1L;  
    }  
    protected void doHead(HttpServletRequest req, HttpServletResponse resp)  
        throws ServletException, IOException  
    {  
        NoBodyResponse response = new NoBodyResponse(resp);  
        doGet(req, response);  
        response.setContentLength();  
    }  
    protected void doPost(HttpServletRequest req, HttpServletResponse resp)  
        throws ServletException, IOException  
    {  
        String protocol = req.getProtocol();  
        String msg = lStrings.getString("http.method_post_not_supported");  
        if(protocol.endsWith("1.1"))  
            resp.sendError(405, msg);  
        else  
            resp.sendError(400, msg);  
    }  
    protected void doPut(HttpServletRequest req, HttpServletResponse resp)  
        throws ServletException, IOException  
    {  
        String protocol = req.getProtocol();  
        String msg = lStrings.getString("http.method_put_not_supported");  
        if(protocol.endsWith("1.1"))  
            resp.sendError(405, msg);  
        else  
            resp.sendError(400, msg);  
    }  
    protected void doDelete(HttpServletRequest req, HttpServletResponse resp)  
        throws ServletException, IOException  
    {  
        String protocol = req.getProtocol();  
        String msg = lStrings.getString("http.method_delete_not_supported");  
        if(protocol.endsWith("1.1"))  
            resp.sendError(405, msg);  
        else  
            resp.sendError(400, msg);  
    }  
    private Method[] getAllDeclaredMethods(Class c)  
    {  
        if(c.equals(javax/servlet/http/HttpServlet))  
            return null;  
        Method parentMethods[] = getAllDeclaredMethods(c.getSuperclass());  
        Method thisMethods[] = c.getDeclaredMethods();  
        if(parentMethods != null && parentMethods.length > 0)  
        {  
            Method allMethods[] = new Method[parentMethods.length + thisMethods.length];  
            System.arraycopy(parentMethods, 0, allMethods, 0, parentMethods.length);  
            System.arraycopy(thisMethods, 0, allMethods, parentMethods.length, thisMethods.length);  
            thisMethods = allMethods;  
        }  
        return thisMethods;  
    }  
    protected void doOptions(HttpServletRequest req, HttpServletResponse resp)  
        throws ServletException, IOException  
    {  
        Method methods[] = getAllDeclaredMethods(getClass());  
        boolean ALLOW_GET = false;  
        boolean ALLOW_HEAD = false;  
        boolean ALLOW_POST = false;  
        boolean ALLOW_PUT = false;  
        boolean ALLOW_DELETE = false;  
        boolean ALLOW_TRACE = true;  
        boolean ALLOW_OPTIONS = true;  
        for(int i = 0; i < methods.length; i++)  
        {  
            Method m = methods[i];  
            if(m.getName().equals("doGet"))  
            {  
                ALLOW_GET = true;  
                ALLOW_HEAD = true;  
            }  
            if(m.getName().equals("doPost"))  
                ALLOW_POST = true;  
            if(m.getName().equals("doPut"))  
                ALLOW_PUT = true;  
            if(m.getName().equals("doDelete"))  
                ALLOW_DELETE = true;  
        }  
        String allow = null;  
        if(ALLOW_GET && allow == null)  
            allow = "GET";  
        if(ALLOW_HEAD)  
            if(allow == null)  
                allow = "HEAD";  
            else  
                allow = (new StringBuilder()).append(allow).append(", HEAD").toString();  
        if(ALLOW_POST)  
            if(allow == null)  
                allow = "POST";  
            else  
                allow = (new StringBuilder()).append(allow).append(", POST").toString();  
        if(ALLOW_PUT)  
            if(allow == null)  
                allow = "PUT";  
            else  
                allow = (new StringBuilder()).append(allow).append(", PUT").toString();  
        if(ALLOW_DELETE)  
            if(allow == null)  
                allow = "DELETE";  
            else  
                allow = (new StringBuilder()).append(allow).append(", DELETE").toString();  
        if(ALLOW_TRACE)  
            if(allow == null)  
                allow = "TRACE";  
            else  
                allow = (new StringBuilder()).append(allow).append(", TRACE").toString();  
        if(ALLOW_OPTIONS)  
            if(allow == null)  
                allow = "OPTIONS";  
            else  
                allow = (new StringBuilder()).append(allow).append(", OPTIONS").toString();  
        resp.setHeader("Allow", allow);  
    }  
    protected void doTrace(HttpServletRequest req, HttpServletResponse resp)  
        throws ServletException, IOException  
    {  
        String CRLF = "
";  
        String responseString = (new StringBuilder()).append("TRACE ").append(req.getRequestURI()).append(" ").append(req.getProtocol()).toString();  
        for(Enumeration reqHeaderEnum = req.getHeaderNames(); reqHeaderEnum.hasMoreElements();)  
        {  
            String headerName = (String)reqHeaderEnum.nextElement();  
            responseString = (new StringBuilder()).append(responseString).append(CRLF).append(headerName).append(": ").append(req.getHeader(headerName)).toString();  
        }  
        responseString = (new StringBuilder()).append(responseString).append(CRLF).toString();  
        int responseLength = responseString.length();  
        resp.setContentType("message/http");  
        resp.setContentLength(responseLength);  
        ServletOutputStream out = resp.getOutputStream();  
        out.print(responseString);  
        out.close();  
    }  
    protected void service(HttpServletRequest req, HttpServletResponse resp)  
        throws ServletException, IOException  
    {  
        String method = req.getMethod();  
        if(method.equals("GET"))  
        {  
            long lastModified = getLastModified(req);  
            if(lastModified == -1L)  
            {  
                doGet(req, resp);  
            } else  
            {  
                long ifModifiedSince = req.getDateHeader("If-Modified-Since");  
                if(ifModifiedSince < (lastModified / 1000L) * 1000L)  
                {  
                    maybeSetLastModified(resp, lastModified);  
                    doGet(req, resp);  
                } else  
                {  
                    resp.setStatus(304);  
                }  
            }  
        } else  
        if(method.equals("HEAD"))  
        {  
            long lastModified = getLastModified(req);  
            maybeSetLastModified(resp, lastModified);  
            doHead(req, resp);  
        } else  
        if(method.equals("POST"))  
            doPost(req, resp);  
        else  
        if(method.equals("PUT"))  
            doPut(req, resp);  
        else  
        if(method.equals("DELETE"))  
            doDelete(req, resp);  
        else  
        if(method.equals("OPTIONS"))  
            doOptions(req, resp);  
        else  
        if(method.equals("TRACE"))  
        {  
            doTrace(req, resp);  
        } else  
        {  
            String errMsg = lStrings.getString("http.method_not_implemented");  
            Object errArgs[] = new Object[1];  
            errArgs[0] = method;  
            errMsg = MessageFormat.format(errMsg, errArgs);  
            resp.sendError(501, errMsg);  
        }  
    }  
    private void maybeSetLastModified(HttpServletResponse resp, long lastModified)  
    {  
        if(resp.containsHeader("Last-Modified"))  
            return;  
        if(lastModified >= 0L)  
            resp.setDateHeader("Last-Modified", lastModified);  
    }  
    public void service(ServletRequest req, ServletResponse res)  
        throws ServletException, IOException  
    {  
        HttpServletRequest request;  
        HttpServletResponse response;  
        try  
        {  
            request = (HttpServletRequest)req;  
            response = (HttpServletResponse)res;  
        }  
        catch(ClassCastException e)  
        {  
            throw new ServletException("non-HTTP request or response");  
        }  
        service(request, response);  
    }  
    private static final String METHOD_DELETE = "DELETE";  
    private static final String METHOD_HEAD = "HEAD";  
    private static final String METHOD_GET = "GET";  
    private static final String METHOD_OPTIONS = "OPTIONS";  
    private static final String METHOD_POST = "POST";  
    private static final String METHOD_PUT = "PUT";  
    private static final String METHOD_TRACE = "TRACE";  
    private static final String HEADER_IFMODSINCE = "If-Modified-Since";  
    private static final String HEADER_LASTMOD = "Last-Modified";  
    private static final String LSTRING_FILE = "javax.servlet.http.LocalStrings";  
    private static ResourceBundle lStrings = ResourceBundle.getBundle("javax.servlet.http.LocalStrings");  
}  

参考：《.init()方法成功完成后,Servlet可以接受请求.默认有多少个Servlet实例被创建》、《Java Servlet(二)：servlet配置及生命周期相关(jdk7+tomcat7+eclipse)》