class_docstr: Multithreaded non-blocking `Resolver` implementation.
  
  Requires the `concurrent.futures` package to be installed
  (available in the standard library since Python 3.2,
  installable with ``pip install futures`` in older versions).
  
  The thread pool size can be configured with::
  
      Resolver.configure('tornado.netutil.ThreadedResolver',
                         num_threads=10)
  
  .. versionchanged:: 3.1
     All ``ThreadedResolvers`` share a single thread pool, whose
     size is set by the first one to be created.
code: def _create_threadpool(cls, num_threads):
      pid = os.getpid()
      if cls._threadpool_pid != pid:
          # Threads cannot survive after a fork, so if our pid isn't what it
          # was when we created the pool then delete it.
          cls._threadpool = None
      if cls._threadpool is None:
          from concurrent.futures import ThreadPoolExecutor
  
          cls._threadpool = ThreadPoolExecutor(num_threads)
          cls._threadpool_pid = pid
      return cls._threadpool
  
imports: from __future__ import absolute_import, division, print_function
  import errno
  import os
  import sys
  import socket
  import stat
  from tornado.concurrent import dummy_executor, run_on_executor
  from tornado.ioloop import IOLoop
  from tornado.platform.auto import set_close_exec
  from tornado.util import PY3, Configurable, errno_from_exception
label_desc: Use image node_id 2 for calling the ThreadedResolver obj's underlying member method code with example usage: obj._create_threadpool(cls, num_threads) and returns: cls