class_docstr: A non-blocking, single-threaded TCP server.
  
  To use `TCPServer`, define a subclass which overrides the `handle_stream`
  method. For example, a simple echo server could be defined like this::
  
    from tornado.tcpserver import TCPServer
    from tornado.iostream import StreamClosedError
    from tornado import gen
  
    class EchoServer(TCPServer):
        @gen.coroutine
        def handle_stream(self, stream, address):
            while True:
                try:
                    data = yield stream.read_until(b"\n")
                    yield stream.write(data)
                except StreamClosedError:
                    break
  
  To make this server serve SSL traffic, send the ``ssl_options`` keyword
  argument with an `ssl.SSLContext` object. For compatibility with older
  versions of Python ``ssl_options`` may also be a dictionary of keyword
  arguments for the `ssl.wrap_socket` method.::
  
     ssl_ctx = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
     ssl_ctx.load_cert_chain(os.path.join(data_dir, "mydomain.crt"),
                             os.path.join(data_dir, "mydomain.key"))
     TCPServer(ssl_options=ssl_ctx)
  
  `TCPServer` initialization follows one of three patterns:
  
  1. `listen`: simple single-process::
  
          server = TCPServer()
          server.listen(8888)
          IOLoop.current().start()
  
  2. `bind`/`start`: simple multi-process::
  
          server = TCPServer()
          server.bind(8888)
          server.start(0)  # Forks multiple sub-processes
          IOLoop.current().start()
  
     When using this interface, an `.IOLoop` must *not* be passed
     to the `TCPServer` constructor.  `start` will always start
     the server on the default singleton `.IOLoop`.
  
  3. `add_sockets`: advanced multi-process::
  
          sockets = bind_sockets(8888)
          tornado.process.fork_processes(0)
          server = TCPServer()
          server.add_sockets(sockets)
          IOLoop.current().start()
  
     The `add_sockets` interface is more complicated, but it can be
     used with `tornado.process.fork_processes` to give you more
     flexibility in when the fork happens.  `add_sockets` can
     also be used in single-process servers if you want to create
     your listening sockets in some way other than
     `~tornado.netutil.bind_sockets`.
  
  .. versionadded:: 3.1
     The ``max_buffer_size`` argument.
docstr: Starts this server in the `.IOLoop`.
  
  By default, we run the server in this process and do not fork any
  additional child process.
  
  If num_processes is ``None`` or <= 0, we detect the number of cores
  available on this machine and fork that number of child
  processes. If num_processes is given and > 1, we fork that
  specific number of sub-processes.
  
  Since we use processes and not threads, there is no shared memory
  between any server code.
  
  Note that multiple processes are not compatible with the autoreload
  module (or the ``autoreload=True`` option to `tornado.web.Application`
  which defaults to True when ``debug=True``).
  When using multiple processes, no IOLoops can be created or
  referenced until after the call to ``TCPServer.start(n)``.
docstr_tok: ["Starts","this","server","in","the","`",".IOLoop","`",".","By","default",",","we","run","the","server","in","this","process","and","do","not","fork","any","additional","child","process",".","If","num_processes","is","``","None","``","or","<","=","0",",","we","detect","the","number","of","cores","available","on","this","machine","and","fork","that","number","of","child","processes",".","If","num_processes","is","given","and",">","1",",","we","fork","that","specific","number","of","sub-processes",".","Since","we","use","processes","and","not","threads",",","there","is","no","shared","memory","between","any","server","code",".","Note","that","multiple","processes","are","not","compatible","with","the","autoreload","module","(","or","the","``","autoreload=True","``","option","to","`","tornado.web.Application","`","which","defaults","to","True","when","``","debug=True","``",")",".","When","using","multiple","processes",",","no","IOLoops","can","be","created","or","referenced","until","after","the","call","to","``","TCPServer.start","(","n",")","``","."]
code: def start(self, num_processes=1):
      """Starts this server in the `.IOLoop`.
  
      By default, we run the server in this process and do not fork any
      additional child process.
  
      If num_processes is ``None`` or <= 0, we detect the number of cores
      available on this machine and fork that number of child
      processes. If num_processes is given and > 1, we fork that
      specific number of sub-processes.
  
      Since we use processes and not threads, there is no shared memory
      between any server code.
  
      Note that multiple processes are not compatible with the autoreload
      module (or the ``autoreload=True`` option to `tornado.web.Application`
      which defaults to True when ``debug=True``).
      When using multiple processes, no IOLoops can be created or
      referenced until after the call to ``TCPServer.start(n)``.
      """
      assert not self._started
      self._started = True
      if num_processes != 1:
          process.fork_processes(num_processes)
      sockets = self._pending_sockets
      self._pending_sockets = []
      self.add_sockets(sockets)
  
imports: from __future__ import absolute_import, division, print_function
  import errno
  import os
  import socket
  from tornado import gen
  from tornado.log import app_log
  from tornado.ioloop import IOLoop
  from tornado.iostream import IOStream, SSLIOStream
  from tornado.netutil import bind_sockets, add_accept_handler, ssl_wrap_socket
  from tornado import process
  from tornado.util import errno_from_exception
label_desc: Use image node_id 6 for calling the TCPServer obj's underlying member method code with example usage: obj.start(num_processes) without return types