Resume the engine.

@param retainedInstance use getRetainInstance.
355777
public void onResume(boolean retainedInstance) {
        if (mBlurredBackgroundView == null || retainedInstance) {
            if (mHoldingActivity.getWindow().getDecorView().isShown()) {
                mBluringTask = new BlurAsyncTask();
                mBluringTask.execute();
            } else {
                mHoldingActivity.getWindow().getDecorView().getViewTreeObserver().addOnPreDrawListener(
                    new ViewTreeObserver.OnPreDrawListener() {
                        @Override
                        public boolean onPreDraw() {
                            // dialog can have been closed before being drawn
                            if (mHoldingActivity != null) {
                                mHoldingActivity.getWindow().getDecorView()
                                    .getViewTreeObserver().removeOnPreDrawListener(this);
                                mBluringTask = new BlurAsyncTask();
                                mBluringTask.execute();
                            }
                            return true;
                        }
                    }
                );
            }
        }
    }
907489
@Override
    public void persist(Object entity)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            Tr.debug(tc, "em.persist(" + entity + ");\n" + toString());

        getEMInvocationInfo(true).persist(entity);
    }
640502
synchronized void resume() {
        paused = false;
        if (activeTask == null) {
            activeTask = new IntervalTask(this);
            timer.schedule(activeTask, interval, interval);
        }
    }
419700
@Override
    public synchronized void resume() {
        this.paused = false;
        ServerActivityCallback listener = listenerUpdater.get(this);
        if (listener != null) {
            listenerUpdater.compareAndSet(this, listener, null);
        }
        while (!taskQueue.isEmpty() && (activeRequestCount < maxRequestCount || maxRequestCount < 0)) {
            runQueuedTask(false);
        }
    }
1129706
@Override
    protected void onRestoreInstanceState(@NonNull Bundle savedInstanceState) {
        super.onRestoreInstanceState(savedInstanceState);
        mExpandableAdapter.onRestoreInstanceState(savedInstanceState);
    }
731820
public function engineResume()
    {
        $this->executeCommandHook(__FUNCTION__, 'before');
        $this->executeExistingCommand('env:resume');
        $this->executeCommandHook(__FUNCTION__, 'after');

        return $this;
    }
1242121
@Override
    public void afterServiceInvoke(Object serviceObject, boolean isSingleton, Object context) {
        @SuppressWarnings("unchecked")
        Map<Class<?>, ManagedObject<?>> newContext = (Map<Class<?>, ManagedObject<?>>) (context);

        ManagedObject<?> mo = newContext.get(serviceObject.getClass());
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "afterServiceInvoke mo=" + mo + " isSingleton=" + isSingleton + " newContext={0}", newContext);
        }
        if (!isSingleton) {
            if (mo != null) {
                mo.release();
            }
            newContext.put(serviceObject.getClass(), null);
        }

    }
992627
@Override
    public boolean invokeEvictable(final Mp instance) throws DempsyException {
        try {
            return instance.shouldBeEvicted();
        } catch(final RuntimeException rte) {
            throw new DempsyException(rte, true);
        }
    }
498174
@Override
    public void registerService(ServiceInstance<T> service) throws Exception
    {
        Entry<T> newEntry = new Entry<T>(service);
        Entry<T> oldEntry = services.putIfAbsent(service.getId(), newEntry);
        Entry<T> useEntry = (oldEntry != null) ? oldEntry : newEntry;
        synchronized(useEntry)
        {
            if ( useEntry == newEntry ) // i.e. is new
            {
                useEntry.cache = makeNodeCache(service);
            }
            internalRegisterService(service);
        }
    }
433765
@Override
    public void unlock(final Object maintainer) throws CouldNotPerformException {
        synchronized (maintainerLock) {
            if (this.maintainer != null && this.maintainer != maintainer) {
                throw new CouldNotPerformException("Could not unlock remote because it is locked by another instance!");
            }
            this.maintainer = null;
        }
    }
312944
public static function resetInstance(): void
    {
        $name = self::$instancePropertyName;
        if (is_object(self::$$name)) {
            if (self::$$name->allowToResetInstance) {
                self::$$name = null;
            } else {
                throw new \RuntimeException(
                    "Resetting of singleton instance disallowed"
                );
            }
        }
    }
509316
public void refreshEntry(com.ibm.wsspi.cache.CacheEntry ce){
		cacheInstance.refreshEntry(ce.cacheEntry);
	}
448700
def resume(self) -> None:
        """"""
        with self.__state_lock:
            if self.__state == DataChannelBuffer.State.paused:
                self.__state = DataChannelBuffer.State.started
985524
@Override protected void onRestoreInstanceState(Bundle savedInstanceState) {
    super.onRestoreInstanceState(savedInstanceState);
    recoverDraggablePanelState(savedInstanceState);
    loadLastPlaceClicked(savedInstanceState);
  }
38591
public void wipeInMemorySettings() {
    this.waitUntilInitialized();

    syncLock.lock();
    try {
      this.instanceChangeStreamListener.stop();
      if (instancesColl.find().first() == null) {
        throw new IllegalStateException("expected to find instance configuration");
      }
      this.syncConfig = new InstanceSynchronizationConfig(configDb);
      this.instanceChangeStreamListener = new InstanceChangeStreamListenerImpl(
          syncConfig,
          service,
          networkMonitor,
          authMonitor
      );
      this.isConfigured = false;
      this.stop();
    } finally {
      syncLock.unlock();
    }
  }
880951
ServerSessionContext setKeepAliveIndex(long keepAliveIndex) {
    long previousKeepAliveIndex = this.keepAliveIndex;
    this.keepAliveIndex = keepAliveIndex;
    if (previousKeepAliveIndex > 0) {
      log.release(previousKeepAliveIndex);
    }
    return this;
  }
471654
def _reset(cls):
        """"""
        if os.getpid() != cls._cls_pid:
            cls._cls_pid = os.getpid()
            cls._cls_instances_by_target.clear()
            cls._cls_thread_by_target.clear()