Synchronously
The current thread relative thread synchronization operation,
blocking the current thread,
thread for the main thread to complete

@param action Action Interface
760867
public static void onUiSync(Action action) {
        if (Looper.myLooper() == Looper.getMainLooper()) {
            action.call();
            return;
        }
        ActionSyncTask poster = new ActionSyncTask(action);
        getUiPoster().sync(poster);
        poster.waitRun();
    }
301530
private void onSynchronization(Node node, EntityMetadata metadata)
    {
        DefaultTransactionResource resource = (DefaultTransactionResource) coordinator.getResource(metadata
                .getPersistenceUnit());
        if (enableFlush)
        {
            resource.onFlush();
        }
        else
        {
            resource.syncNode(node);
        }
    }
285386
public void setAction(String action)
    {
        ExtendedInfo info = getInfo(action);
        if (info != null)
            info._action = action;
    }
159597
public void commitTask(
      String trackerName, InetAddress addr, CommitTaskAction action) {
    String description = "KillTaskAction " + action.getTaskID();
    LOG.info("Queueing " + description + " to worker " +
      trackerName + "(" + addr.host + ":" + addr.port + ")");
    allWorkQueues.enqueueAction(new ActionToSend(
        trackerName, addr, action, description));
  }
1203439
@Override
    public void synchronizeThreadDevice(Long threadId, Integer deviceId, AllocationPoint point) {
        // we synchronize only if this AllocationPoint was used within device context, so for multiple consequent syncs only first one will be issued
        flowController.synchronizeToHost(point);
    }
713297
public Stream<T> onNext(final Action1<? super T> action) {
        return new Stream<T>() {
            @Override
            public Iterator<T> iterator() {
                return new ReadOnlyIterator<T>() {

                    Iterator<T> iterator = Stream.this.iterator();

                    @Override
                    public boolean hasNext() {
                        return iterator.hasNext();
                    }

                    @Override
                    public T next() {
                        final T next = iterator.next();
                        action.call(next);
                        return next;
                    }
                };
            }
        };
    }
530612
public void ordered(Consumer<T> action) {
        TopoSorter<T> sorter = new TopoSorter<>(this);
        sorter.ordered(action);
    }
756002
public void asyncOperationStarted() {
    if (syncThread == Thread.currentThread()) {
      synchronized (entry) {
        while (entry.isProcessing()) {
          try {
            entry.wait();
          } catch (InterruptedException ex) {
            Thread.currentThread().interrupt();
          }
        }
      }
    } else {
      entryLocked = false;
    }
  }
1139702
protected <T> T executeIgnoreRollback(TransactionCallback<T> action, T rollbackValue) {
        try {
            // Try to create the mutex in a new TX
            return this.newTransactionTemplate.execute(action);
        } catch (TransactionSystemException e) {
            if (e.getCause() instanceof RollbackException) {
                // Ignore rollbacks
                return rollbackValue;
            }

            // re-throw exception with unhandled cause
            throw e;
        }
    }
441458
public function setCurrentAction($action): void
    {
        if (!$action instanceof Action) {
            $action = $this->getAction($action);
        }
        $this->currentAction = $action;
    }
449854
public void forEach(@NotNull final Consumer<? super T> action) {
        while (iterator.hasNext()) {
            action.accept(iterator.next());
        }
    }
117379
@UiThread
  @SafeVarargs public static <T extends View> void run(@NonNull T[] array,
      @NonNull Action<? super T>... actions) {
    for (int i = 0, count = array.length; i < count; i++) {
      for (Action<? super T> action : actions) {
        action.apply(array[i], i);
      }
    }
  }
43080
function(syncAction){
    var oldAction = this.syncAction;

    if (typeof syncAction != 'function')
      syncAction = null;

    this.syncAction = syncAction;

    if (syncAction)
    {
      if (!oldAction)
        this.addHandler(this.syncEvents);
      if (this.isSyncRequired())
        callSyncAction(this);
    }
    else
    {
      if (oldAction)
        this.removeHandler(this.syncEvents);
    }
  }
52240
@Override
    public void tryUnchecked(ActionToTry<E> action) {
        tryUnchecked(noParam -> {
            action.execute();
            return null;
        }, null);
    }
1061252
private void syncToOSThread(WebSecurityContext webSecurityContext) throws SecurityViolationException {
        try {
            Object token = ThreadIdentityManager.setAppThreadIdentity(subjectManager.getInvocationSubject());
            webSecurityContext.setSyncToOSThreadToken(token);
        } catch (ThreadIdentityException tie) {
            SecurityViolationException secVE = convertWebSecurityException(new WebSecurityCollaboratorException(tie.getMessage(), DENY_AUTHZ_FAILED, webSecurityContext));
            throw secVE;
        }
    }
149222
@Override
    public void addAction(final LifecycleStage stage, final LifecycleAction<T> action)
    {
        stageEvents.add(new StageEvent(stage, action));
    }
70762
public function wait($action)
    {
        $lead = $this->conversation->get('lead');

        // For chaining after $bot->say() method
        if ($lead != null) {
            $lead->data('_wait', $action);
        } // For chaining after $bot->answer() method
        else {
            $this->model->addIntendedAction($action);
        }
    }