docs: def realise(self):
          """
          Realise the future if possible
  
          If the future has not been realised yet, do so in the current thread.
          This will block execution until the future is realised.
          Otherwise, do not block but return whether the result is already available.
  
          This will not return the result nor propagate any exceptions of the future itself.
  
          :return: whether the future has been realised
          :rtype: bool
          """
          if self._mutex.acquire(False):
              # realise the future in this thread
              try:
                  if self._result is not None:
                      return True
                  call, args, kwargs = self._instruction
                  try:
                      result = call(*args, **kwargs)
                  except BaseException as err:
                      self._result = None, err
                  else:
                      self._result = result, None
                  return True
              finally:
                  self._mutex.release()
          else:
              # indicate whether the executing thread is done
              return self._result is not None