class_docstr: Same as :class:`MapData`, but start threads to run the mapping function.
  This is useful when the mapping function is the bottleneck, but you don't
  want to start processes for the entire dataflow pipeline.
  
  The semantics of this class is **identical** to :class:`MapData` except for the ordering.
  Threads run in parallel and can take different time to run the
  mapping function. Therefore the order of datapoints won't be preserved.
  
  When ``strict=True``, ``MultiThreadMapData(df, ...)``
  is guaranteed to produce the exact set of data as ``MapData(df, ...)``,
  if both are iterated until ``StopIteration``. But the produced data will have different ordering.
  The behavior of strict mode is undefined if the given dataflow ``df`` is infinite.
  
  When ``strict=False``, the data that's produced by ``MultiThreadMapData(df, ...)``
  is a reordering of the data produced by ``RepeatedData(MapData(df, ...), -1)``.
  In other words, first pass of ``MultiThreadMapData.__iter__`` may contain
  datapoints from the second pass of ``df.__iter__``.
  
  
  Note:
      1. You should avoid starting many threads in your main process to reduce GIL contention.
  
         The threads will only start in the process which calls :meth:`reset_state()`.
         Therefore you can use ``MultiProcessRunnerZMQ(MultiThreadMapData(...), 1)``
         to reduce GIL contention.
code: def _send(self, dp):
      self._in_queue.put(dp)
  
imports: import copy
  import ctypes
  import multiprocessing
  import numpy
  import threading
  import zmq
  from six.moves import queue
  from ..utils.concurrency import StoppableThread, enable_death_signal
  from ..utils.serialize import dumps_once, loads_once
  from .base import DataFlow, DataFlowReentrantGuard, ProxyDataFlow
  from .common import RepeatedData, BatchData
  from .parallel import _bind_guard, _get_pipe_name, _MultiProcessZMQDataFlow, _repeat_iter, _zmq_catch_error
label_desc: Use image node_id 4 for calling the MultiThreadMapData obj's underlying member method code with example usage: obj._send(dp) without return types