code: def next(self):
          
          # pylint: disable=protected-access
          while True:
              if self._pcontext.thread_num == 0 and self._pcontext.num_threads > 1:
                  # Producer.
                  for iter_elem in self._iterable:
                      self._queue.put(iter_elem, timeout=self._element_timeout)
                  for _ in range(self._pcontext.num_threads - 1):
                      self._queue.put(
                          "__queueend__:%d" % (self._pcontext._thread_loop_ids[0])
                      )
                  raise StopIteration()
              elif self._pcontext.num_threads > 1:
                  # Consumer.
                  # Check that the pool still deals with this loop.
                  # pylint: disable=protected-access
                  with self._pcontext._queuelock:
                      pool_loop_reached = max(self._pcontext._thread_loop_ids)
                      master_reached = self._pcontext._thread_loop_ids[0]
                  if pool_loop_reached > self._loop_id:
                      raise StopIteration()
                  elif master_reached < self._loop_id:
                      # The producer did not reach this loop yet.
                      _time.sleep(.1)
                      continue
                  else:
                      try:
                          queue_elem = self._queue.get(timeout=0.1)
                      except _Queue.Empty:
                          continue
                      if queue_elem == "__queueend__:%d" % self._loop_id:
                          raise StopIteration()
                      else:
                          return queue_elem
              else:
                  # Single thread execution.
                  # Should have never reached here, since this case is dealt with
                  # in the __iter__ method!
                  raise Exception("Internal error!")
docs: Iterator implementation.