application = web.Application([            (r"/", MainPageHandler),        ])        http_server = httpserver.HTTPServer(application)        http_server.listen(8080)        ioloop.IOLoop.instance().start()

    def listen(self, port, address="", **kwargs):        from tornado.httpserver import HTTPServer        server = HTTPServer(self, **kwargs)        server.listen(port, address)

    A non-blocking, single-threaded HTTP server.    A server is defined by a request callback that takes an HTTPRequest    instance as an argument and writes a valid HTTP response with    `HTTPRequest.write`. `HTTPRequest.finish` finishes the request (but does    not necessarily close the connection in the case of HTTP/1.1 keep-alive    requests).

class HTTPServer(TCPServer):        def __init__(self, request_callback, no_keep_alive=False, io_loop=None,                 xheaders=False, ssl_options=None, protocol=None, **kwargs):        self.request_callback = request_callback        self.no_keep_alive = no_keep_alive        self.xheaders = xheaders        self.protocol = protocol        TCPServer.__init__(self, io_loop=io_loop, ssl_options=ssl_options,                           **kwargs)    def handle_stream(self, stream, address):        HTTPConnection(stream, address, self.request_callback,                       self.no_keep_alive, self.xheaders, self.protocol)

class TCPServer(object):        def __init__(self, io_loop=None, ssl_options=None, max_buffer_size=None):        self.io_loop = io_loop        self.ssl_options = ssl_options        self._sockets = {}  # fd -> socket object，保存socket        self._pending_sockets = []        self._started = False        self.max_buffer_size = max_buffer_size        if self.ssl_options is not None and isinstance(self.ssl_options, dict):            ...    def listen(self, port, address=""):        sockets = bind_sockets(port, address=address)        self.add_sockets(sockets)    def add_sockets(self, sockets):        if self.io_loop is None:            self.io_loop = IOLoop.current()        for sock in sockets:            self._sockets[sock.fileno()] = sock            add_accept_handler(sock, self._handle_connection,                               io_loop=self.io_loop)    def _handle_connection(self, connection, address):        if self.ssl_options is not None:            assert ssl, "Python 2.6+ and OpenSSL required for SSL"            try:                connection = ssl_wrap_socket(connection,                                             self.ssl_options,                                             server_side=True,                                             do_handshake_on_connect=False)            except ssl.SSLError as err:                if err.args[0] == ssl.SSL_ERROR_EOF:                    return connection.close()                else:                    raise            except socket.error as err:                # If the connection is closed immediately after it is created                # (as in a port scan), we can get one of several errors.                # wrap_socket makes an internal call to getpeername,                # which may return either EINVAL (Mac OS X) or ENOTCONN                # (linux).  If it returns ENOTCONN, this error is                # silently swallowed by the ssl module, so we need to                # catch another error later on (AttributeError in                # SSLIOStream._do_ssl_handshake).                # To test this behavior, try nmap with the -sT flag.                # https://github.com/tornadoweb/tornado/pull/750                if err.args[0] in (errno.ECONNABORTED, errno.EINVAL):                    return connection.close()                else:                    raise        try:            if self.ssl_options is not None:                stream = SSLIOStream(connection, io_loop=self.io_loop, max_buffer_size=self.max_buffer_size)            else:                stream = IOStream(connection, io_loop=self.io_loop, max_buffer_size=self.max_buffer_size)            self.handle_stream(stream, address)        except Exception:            app_log.error("Error in connection callback", exc_info=True)

def bind_sockets(port, address=None, family=socket.AF_UNSPEC, backlog=128, flags=None):    sockets = []    if address == "":        address = None    if not socket.has_ipv6 and family == socket.AF_UNSPEC:        # Python can be compiled with --disable-ipv6, which causes        # Operations on AF_INET6 sockets to fail, but does not        # automatically exclude those results from getaddrinfo        # results.        # http://bugs.python.org/issue16208        family = socket.AF_INET    if flags is None:        flags = socket.AI_PASSIVE    for res in set(socket.getaddrinfo(address, port, family, socket.SOCK_STREAM,                                      0, flags)):        af, socktype, proto, canonname, sockaddr = res        try:            sock = socket.socket(af, socktype, proto)        except socket.error as e:            if e.args[0] == errno.EAFNOSUPPORT:                continue            raise        set_close_exec(sock.fileno())        if os.name != 'nt':            sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)        if af == socket.AF_INET6:            # On linux, ipv6 sockets accept ipv4 too by default,            # but this makes it impossible to bind to both            # 0.0.0.0 in ipv4 and :: in ipv6.  On other systems,            # separate sockets *must* be used to listen for both ipv4            # and ipv6.  For consistency, always disable ipv4 on our            # ipv6 sockets and use a separate ipv4 socket when needed.            #            # Python 2.x on windows doesn't have IPPROTO_IPV6.            if hasattr(socket, "IPPROTO_IPV6"):                sock.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 1)        sock.setblocking(0)        sock.bind(sockaddr)        sock.listen(backlog)        sockets.append(sock)    return sockets

def add_accept_handler(sock, callback, io_loop=None):    if io_loop is None:        io_loop = IOLoop.current()            def accept_handler(fd, events):        while True:            try:                connection, address = sock.accept()            except socket.error as e:                # EWOULDBLOCK and EAGAIN indicate we have accepted every                # connection that is available.                if e.args[0] in (errno.EWOULDBLOCK, errno.EAGAIN):                    return                # ECONNABORTED indicates that there was a connection                # but it was closed while still in the accept queue.                # (observed on FreeBSD).                if e.args[0] == errno.ECONNABORTED:                    continue                raise            callback(connection, address)                io_loop.add_handler(sock.fileno(), accept_handler, IOLoop.READ)

    def _handle_connection(self, connection, address):        if self.ssl_options is not None:            assert ssl, "Python 2.6+ and OpenSSL required for SSL"            try:                connection = ssl_wrap_socket(connection,                                             self.ssl_options,                                             server_side=True,                                             do_handshake_on_connect=False)            except ssl.SSLError as err:                if err.args[0] == ssl.SSL_ERROR_EOF:                    return connection.close()                else:                    raise            except socket.error as err:                # If the connection is closed immediately after it is created                # (as in a port scan), we can get one of several errors.                # wrap_socket makes an internal call to getpeername,                # which may return either EINVAL (Mac OS X) or ENOTCONN                # (Linux).  If it returns ENOTCONN, this error is                # silently swallowed by the ssl module, so we need to                # catch another error later on (AttributeError in                # SSLIOStream._do_ssl_handshake).                # To test this behavior, try nmap with the -sT flag.                # https://github.com/tornadoweb/tornado/pull/750                if err.args[0] in (errno.ECONNABORTED, errno.EINVAL):                    return connection.close()                else:                    raise        try:            if self.ssl_options is not None:                stream = SSLIOStream(connection, io_loop=self.io_loop, max_buffer_size=self.max_buffer_size)            else:                stream = IOStream(connection, io_loop=self.io_loop, max_buffer_size=self.max_buffer_size)            self.handle_stream(stream, address)        except Exception:            app_log.error("Error in connection callback", exc_info=True)

    def handle_stream(self, stream, address):        HTTPConnection(stream, address, self.request_callback,                       self.no_keep_alive, self.xheaders, self.protocol)

class HTTPConnection(object):    def __init__(self, stream, address, request_callback, no_keep_alive=False,                 xheaders=False, protocol=None):        self.stream = stream        self.address = address        # Save the socket's address family now so we know how to        # interpret self.address even after the stream is closed        # and its socket attribute replaced with None.        self.address_family = stream.socket.family        self.request_callback = request_callback        self.no_keep_alive = no_keep_alive        self.xheaders = xheaders        self.protocol = protocol        self._clear_request_state()        # Save stack context here, outside of any request.  This keeps        # contexts from one request from leaking into the next.        self._header_callback = stack_context.wrap(self._on_headers)        self.stream.set_close_callback(self._on_connection_close)        self.stream.read_until(b"/r/n/r/n", self._header_callback)

    def _clear_request_state(self):        self._request = None        self._request_finished = False        self._write_callback = None        self._close_callback = None

    def set_close_callback(self, callback):        self._close_callback = stack_context.wrap(callback)    def _on_connection_close(self):        if self._close_callback is not None:            callback = self._close_callback            self._close_callback = None            callback()        # Delete any unfinished callbacks to break up reference cycles.        self._header_callback = None        self._clear_request_state()

def _on_headers(self, data):        try:            data = native_str(data.decode('latin1'))            eol = data.find("/r/n")            start_line = data[:eol]            try:                method, uri, version = start_line.split(" ")            except ValueError:                raise _BadRequestException("Malformed HTTP request line")            if not version.startswith("HTTP/"):                raise _BadRequestException("Malformed HTTP version in HTTP Request-Line")            try:                headers = httputil.HTTPHeaders.parse(data[eol:])            except ValueError:                # Probably from split() if there was no ':' in the line                raise _BadRequestException("Malformed HTTP headers")            # HTTPRequest wants an IP, not a full socket address            if self.address_family in (socket.AF_INET, socket.AF_INET6):                remote_ip = self.address[0]            else:                # Unix (or other) socket; fake the remote address                remote_ip = '0.0.0.0'            self._request = HTTPRequest(                connection=self, method=method, uri=uri, version=version,                headers=headers, remote_ip=remote_ip, protocol=self.protocol)            content_length = headers.get("Content-Length")            if content_length:                content_length = int(content_length)                if content_length > self.stream.max_buffer_size:                    raise _BadRequestException("Content-Length too long")                if headers.get("Expect") == "100-continue":                    self.stream.write(b"HTTP/1.1 100 (Continue)/r/n/r/n")                self.stream.read_bytes(content_length, self._on_request_body)                return            self.request_callback(self._request)        except _BadRequestException as e:            gen_log.info("Malformed HTTP request from %r: %s",                         self.address, e)            self.close()            return