Java Semaphore.waitFor方法代码示例

import com.intellij.util.concurrency.Semaphore; //导入方法依赖的package包/类
public static void smartInvokeAndWait(final Project p, final ModalityState state, final Runnable r) {
    if (isNoBackgroundMode() || ApplicationManager.getApplication().isDispatchThread()) {
        r.run();
    } else {
        final Semaphore semaphore = new Semaphore();
        semaphore.down();
        DumbService.getInstance(p).smartInvokeLater(() -> {
            try {
                r.run();
            } finally {
                semaphore.up();
            }
        }, state);
        semaphore.waitFor();
    }
}
 

import com.intellij.util.concurrency.Semaphore; //导入方法依赖的package包/类
public SvnCopiesRefreshManager(final SvnFileUrlMappingImpl mapping) {
  mySemaphore = new Semaphore();
  // svn mappings refresh inside also uses asynchronous pass -> we need to pass callback that will ping our "single-threaded" executor here
  myMappingCallback = new Runnable() {
    @Override
    public void run() {
      mySemaphore.up();
    }
  };
  myRequestsMerger = new RequestsMerger(new Runnable() {
    @Override
    public void run() {
      mySemaphore.down();
      mapping.realRefresh(myMappingCallback);
      mySemaphore.waitFor();
    }
  }, new Consumer<Runnable>() {
    public void consume(final Runnable runnable) {
      ApplicationManager.getApplication().executeOnPooledThread(runnable);
    }
  });
}
 

import com.intellij.util.concurrency.Semaphore; //导入方法依赖的package包/类
public T compute() {
  final Semaphore semaphore = new Semaphore();
  semaphore.down();
  final AtomicReference<T> reference = new AtomicReference<T>();
  ApplicationManager.getApplication().executeOnPooledThread(new Runnable() {
    @Override
    public void run() {
      try {
        reference.set(runImpl());
      }
      finally {
        semaphore.up();
      }
    }
  });
  semaphore.waitFor();
  return reference.get();
}
 

import com.intellij.util.concurrency.Semaphore; //导入方法依赖的package包/类
public void waitForCompletion() {
  if (isStopped) return;

  if (ApplicationManager.getApplication().isUnitTestMode()) {
    synchronized (myQueue) {
      while (!myQueue.isEmpty()) {
        startProcessing(myQueue.poll());
      }
    }
    return;
  }

  final Semaphore semaphore = new Semaphore();
  semaphore.down();
  scheduleTask(new MavenProjectsProcessorTask() {
    public void perform(Project project, MavenEmbeddersManager embeddersManager, MavenConsole console, MavenProgressIndicator indicator)
      throws MavenProcessCanceledException {
      semaphore.up();
    }
  });

  while (true) {
    if (isStopped || semaphore.waitFor(1000)) return;
  }
}
 

import com.intellij.util.concurrency.Semaphore; //导入方法依赖的package包/类
public void startAndWait(final LineProcessEventListener listener) {
  final Semaphore semaphore = new Semaphore();
  semaphore.down();
  addListener(new LineProcessEventListener() {
    @Override
    public void onLineAvailable(final String s, final Key key) {
      listener.onLineAvailable(s, key);
    }

    @Override
    public void processTerminated(final int i) {
      listener.processTerminated(i);
      semaphore.up();
    }

    @Override
    public void startFailed(final Throwable throwable) {
      listener.startFailed(throwable);
      semaphore.up();
    }
  });
  start();
  semaphore.waitFor();
}
 

import com.intellij.util.concurrency.Semaphore; //导入方法依赖的package包/类
@TestOnly
public void waitUntilRefreshed() {
  while (true) {
    final Semaphore semaphore = new Semaphore();
    synchronized (myLock) {
      if (!myRequestSubmitted && !myRequestRunning) {
        return;
      }

      if (!myRequestRunning) {
        myScheduler.submit(new MyRunnable());
      }

      semaphore.down();
      myWaitingUpdateCompletionSemaphores.add(semaphore);
    }
    if (!semaphore.waitFor(100*1000)) {
      LOG.error("Too long VCS update");
      return;
    }
  }
}
 

import com.intellij.util.concurrency.Semaphore; //导入方法依赖的package包/类
public void freeze(@Nonnull String reason) {
  myUpdater.setIgnoreBackgroundOperation(true);
  Semaphore sem = new Semaphore();
  sem.down();

  invokeAfterUpdate(() -> {
    myUpdater.setIgnoreBackgroundOperation(false);
    myUpdater.pause();
    myFreezeName.set(reason);
    sem.up();
  }, InvokeAfterUpdateMode.SILENT_CALLBACK_POOLED, "", ModalityState.defaultModalityState());

  boolean free = false;
  while (!free) {
    ProgressIndicator pi = ProgressManager.getInstance().getProgressIndicator();
    if (pi != null) pi.checkCanceled();
    free = sem.waitFor(500);
  }
}
 

import com.intellij.util.concurrency.Semaphore; //导入方法依赖的package包/类
@Override
public Future<?> startThread(final ProgressIndicator progressIndicator, final Runnable runnable) {
  final Semaphore startSemaphore = new Semaphore();
  startSemaphore.down();
  Future<?> future = ApplicationManager.getApplication().executeOnPooledThread(() -> ProgressManager.getInstance().runProcess(() -> {
    try {
      ApplicationManager.getApplication().runReadAction(() -> {
        startSemaphore.up();
        ProgressManager.checkCanceled();
        runnable.run();
      });
    } catch (ProcessCanceledException ignored) {
    }
  }, progressIndicator));
  startSemaphore.waitFor();
  return future;
}
 

import com.intellij.util.concurrency.Semaphore; //导入方法依赖的package包/类
private static void synchronousBackground(final Runnable runnable) throws InterruptedException {
  final Semaphore semaphore = new Semaphore();
  semaphore.down();
  ApplicationManager.getApplication().executeOnPooledThread(new Runnable() {
    @Override
    public void run() {
      try {
        runnable.run();
      } finally {
        semaphore.up();
      }
    }
  });
  semaphore.waitFor();
}
 

import com.intellij.util.concurrency.Semaphore; //导入方法依赖的package包/类
@Override
public Value getValue() {
  // the following code makes sense only if we do not use ObjectReference.enableCollection() / disableCollection()
  // to keep temporary objects
  if (Patches.IBM_JDK_DISABLE_COLLECTION_BUG) {
    final EvaluationContextImpl evalContext = myStoredEvaluationContext;
    if (evalContext != null && !evalContext.getSuspendContext().isResumed() &&
      myValue instanceof ObjectReference && VirtualMachineProxyImpl.isCollected((ObjectReference)myValue)) {

      final Semaphore semaphore = new Semaphore();
      semaphore.down();
      evalContext.getDebugProcess().getManagerThread().invoke(new SuspendContextCommandImpl(evalContext.getSuspendContext()) {
        @Override
        public void contextAction() throws Exception {
          // re-setting the context will cause value recalculation
          try {
            setContext(myStoredEvaluationContext);
          }
          finally {
            semaphore.up();
          }
        }

        @Override
        protected void commandCancelled() {
          semaphore.up();
        }
      });
      semaphore.waitFor();
    }
  }

  assertValueReady();
  return myValue; 
}
 

import com.intellij.util.concurrency.Semaphore; //导入方法依赖的package包/类
public <V> V queueAndWaitTask(final Callable<V> task) throws Throwable {
  final Ref<V> resultRef = new Ref<V>();
  final Ref<Throwable> throwableRef = new Ref<Throwable>();

  final Semaphore taskSemaphore = new Semaphore();
  taskSemaphore.down();

  queueTask(new Runnable() {

    @Override
    public void run() {
      try {
        resultRef.set(task.call());
      }
      catch (Throwable e) {
        throwableRef.set(e);
        LOG.error(e);
      }
      finally {
        taskSemaphore.up();
      }
    }
  });

  taskSemaphore.waitFor();

  if (!throwableRef.isNull()) {
    throw throwableRef.get();
  }

  return resultRef.get();
}
 

import com.intellij.util.concurrency.Semaphore; //导入方法依赖的package包/类
public static void close(final Process process) {
  final Semaphore outerSemaphore = new Semaphore();
  outerSemaphore.down();

  final Application application = ApplicationManager.getApplication();
  application.executeOnPooledThread(new Runnable() {
    public void run() {
      try {
        final Semaphore semaphore = new Semaphore();
        semaphore.down();

        final Runnable closeRunnable = new Runnable() {
          public void run() {
            try {
              closeProcessImpl(process);
            }
            finally {
              semaphore.up();
            }
          }
        };

        final Future<?> innerFuture = application.executeOnPooledThread(closeRunnable);
        semaphore.waitFor(ourAsynchronousWaitTimeout);
        if ( ! (innerFuture.isDone() || innerFuture.isCancelled())) {
          innerFuture.cancel(true); // will call interrupt()
        }
      }
      finally {
        outerSemaphore.up();
      }
    }
  });

  // just wait
  outerSemaphore.waitFor(ourSynchronousWaitTimeout);
}
 

import com.intellij.util.concurrency.Semaphore; //导入方法依赖的package包/类
private boolean runTasksQueue(final Queue<Pair<ProjectSystemId, ExternalSystemTaskExecutionSettings>> tasksQueue) {
  final Pair<ProjectSystemId, ExternalSystemTaskExecutionSettings> pair = tasksQueue.poll();
  if (pair == null) return true;

  final ProjectSystemId systemId = pair.first;
  final ExternalSystemTaskExecutionSettings executionSettings = pair.getSecond();

  final Semaphore targetDone = new Semaphore();
  targetDone.down();
  final Ref<Boolean> result = new Ref<Boolean>(false);
  ExternalSystemUtil.runTask(executionSettings, DefaultRunExecutor.EXECUTOR_ID, myProject, systemId,
                             new TaskCallback() {
                               @Override
                               public void onSuccess() {
                                 result.set(runTasksQueue(tasksQueue));
                                 targetDone.up();
                               }

                               @Override
                               public void onFailure() {
                                 targetDone.up();
                               }
                             },
                             ProgressExecutionMode.IN_BACKGROUND_ASYNC);
  targetDone.waitFor();
  return result.get();
}
 

import com.intellij.util.concurrency.Semaphore; //导入方法依赖的package包/类
private static void synchronousBackground(final Runnable runnable) throws InterruptedException {
  final Semaphore semaphore = new Semaphore();
  semaphore.down();
  ApplicationManager.getApplication().executeOnPooledThread((Runnable)() -> {
    try {
      runnable.run();
    } finally {
      semaphore.up();
    }
  });
  semaphore.waitFor();
}
 

import com.intellij.util.concurrency.Semaphore; //导入方法依赖的package包/类
private static void waitAndPump(Semaphore semaphore, int timeout) {
  final long limit = System.currentTimeMillis() + timeout;
  while (System.currentTimeMillis() < limit) {
    if (semaphore.waitFor(10)) return;
    UIUtil.dispatchAllInvocationEvents();
  }
  fail("Timeout");
}