docs: def start_update(self, draw=None, queues=None, update_shared=True):
          """
          Conduct the registered plot updates
  
          This method starts the updates from what has been registered by the
          :meth:`update` method. You can call this method if you did not set the
          `auto_update` parameter to True when calling the :meth:`update` method
          and when the :attr:`no_auto_update` attribute is True.
  
          Parameters
          ----------
          %(InteractiveBase.start_update.parameters)s
  
          Returns
          -------
          %(InteractiveBase.start_update.returns)s
  
          See Also
          --------
          :attr:`no_auto_update`, update"""
          def update_the_others():
              for fmto in fmtos:
                  for other_fmto in fmto.shared:
                      if not other_fmto.plotter._updating:
                          other_fmto.plotter._register_update(
                              force=[other_fmto.key])
              for fmto in fmtos:
                  for other_fmto in fmto.shared:
                      if not other_fmto.plotter._updating:
                          other_draw = other_fmto.plotter.start_update(
                              draw=False, update_shared=False)
                          if other_draw:
                              self._figs2draw.add(
                                  other_fmto.plotter.ax.get_figure())
          if self.disabled:
              return False
  
          if queues is not None:
              queues[0].get()
          self.logger.debug("Starting update of %r",
                            self._registered_updates.keys())
          # update the formatoptions
          self._save_state()
          try:
              # get the formatoptions. We sort them here by key to make sure that
              # the order always stays the same (easier for debugging)
              fmtos = sorted(self._set_and_filter(), key=lambda fmto: fmto.key)
          except Exception:
              # restore last (working) state
              last_state = self._old_fmt.pop(-1)
              with self.no_validation:
                  for key in self:
                      self[key] = last_state.get(key, getattr(self, key).default)
              if queues is not None:
                  queues[0].task_done()
              self._release_all(queue=None if queues is None else queues[1])
              # raise the error
              raise
          for fmto in fmtos:
              for fmto2 in fmto.shared:
                  fmto2.plotter._to_update[fmto2] = self
          if queues is not None:
              self._updating = True
              queues[0].task_done()
              # wait for the other tasks to finish
              queues[0].join()
              queues[1].get()
          fmtos.extend([fmto for fmto in self._insert_additionals(list(
              self._to_update)) if fmto not in fmtos])
          self._to_update.clear()
  
          fmto_groups = self._grouped_fmtos(self._sorted_by_priority(fmtos[:]))
          # if any formatoption requires a clearing of the axes is updated,
          # we reinitialize the plot
          if self.cleared:
              self.reinit(draw=draw)
              update_the_others()
              self._release_all(queue=None if queues is None else queues[1])
              return True
          # otherwise we update it
          arr_draw = False
          try:
              for priority, grouper in fmto_groups:
                  arr_draw = True
                  self._plot_by_priority(priority, grouper)
              update_the_others()
          except Exception:
              raise
          finally:
              # make sure that all locks are released
              self._release_all(finish=True,
                                queue=None if queues is None else queues[1])
          if draw is None:
              draw = rcParams['auto_draw']
          if draw and arr_draw:
              self.draw()
              if rcParams['auto_show']:
                  self.show()
          self.replot = False
          return arr_draw