Java Semaphore类代码示例

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包/类
protected void run(final SR serverRuntime, final Semaphore semaphore, final AtomicReference<T> result) {
  serverRuntime.getTaskExecutor().submit(new Runnable() {

    @Override
    public void run() {
      try {
        result.set(CloudRuntimeTask.this.run(serverRuntime));
        mySuccess.set(true);
      }
      catch (ServerRuntimeException e) {
        runtimeErrorOccurred(e.getMessage());
      }
      finally {
        semaphore.up();
      }
    }
  });
}
 

import com.intellij.util.concurrency.Semaphore; //导入依赖的package包/类
private int waitForSemaphore(final Semaphore semaphore) {
  long timeoutMs = myTimeUnit.toMillis(myTimeout);
  long lastActiveMoment = System.currentTimeMillis();
  while (true) {
    long current = System.currentTimeMillis();
    if (myIsTouched) {
      myIsTouched = false;
      lastActiveMoment = current;
    }
    
    long idleTime = current - lastActiveMoment;
    if (idleTime > timeoutMs) {
      int retCode = processTimeoutInEDT();
      return semaphore.waitFor(0) ? 0 : retCode;
    }
    
    ProgressManager.checkCanceled();

    if (semaphore.waitFor(Math.min(500, timeoutMs - idleTime))) {
      return 0;
    }
  }
}
 

import com.intellij.util.concurrency.Semaphore; //导入依赖的package包/类
@Override
public void waitForSmartMode() {
  if (!isDumb()) {
    return;
  }

  final Application application = ApplicationManager.getApplication();
  if (application.isReadAccessAllowed() || application.isDispatchThread()) {
    throw new AssertionError("Don't invoke waitForSmartMode from inside read action in dumb mode");
  }

  final Semaphore semaphore = new Semaphore();
  semaphore.down();
  runWhenSmart(new Runnable() {
    @Override
    public void run() {
      semaphore.up();
    }
  });
  while (true) {
    if (semaphore.waitFor(50)) {
      return;
    }
    ProgressManager.checkCanceled();
  }
}
 

import com.intellij.util.concurrency.Semaphore; //导入依赖的package包/类
static void invokeAndWait(@NotNull final Runnable runnable, @NotNull ModalityState modalityState) {
  LOG.assertTrue(!isDispatchThread());

  final Semaphore semaphore = new Semaphore();
  semaphore.down();
  Runnable runnable1 = new Runnable() {
    @Override
    public void run() {
      try {
        runnable.run();
      }
      finally {
        semaphore.up();
      }
    }

    @Override
    @NonNls
    public String toString() {
      return "InvokeAndWait[" + runnable + "]";
    }
  };
  invokeLater(runnable1, modalityState);
  semaphore.waitFor();
}
 

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包/类
@TestOnly
public void waitUntilRefreshed() {
  while (true) {
    final Semaphore semaphore = new Semaphore();
    synchronized (myLock) {
      if (!myRequestSubmitted && !myRequestRunning) {
        return;
      }

      if (!myRequestRunning) {
        myExecutor.get().schedule(new MyRunnable(), 0, TimeUnit.MILLISECONDS);
      }

      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 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 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(new Runnable() {
      @Override
      public void run() {
        try {
          r.run();
        }
        finally {
          semaphore.up();
        }
      }
    }, state);
    semaphore.waitFor();
  }
}
 

import com.intellij.util.concurrency.Semaphore; //导入依赖的package包/类
private void waitForProcess(Application application) {
  myWaitSemaphore = new Semaphore();
  myWaitSemaphore.down();
  myWaitForThreadFuture = application.executeOnPooledThread(new Runnable() {
    public void run() {
      try {
        myProcess.waitFor();
      }
      catch (InterruptedException ignored) {
      }
      finally {
        myWaitSemaphore.up();
      }
    }
  });
}
 

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 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包/类
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 && myStoredEvaluationContext != null && !myStoredEvaluationContext.getSuspendContext().isResumed() &&
      myValue instanceof ObjectReference && VirtualMachineProxyImpl.isCollected((ObjectReference)myValue)) {

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

import com.intellij.util.concurrency.Semaphore; //导入依赖的package包/类
public static void invokeAndWait(@NotNull final Runnable runnable, @NotNull ModalityState modalityState) {
  LOG.assertTrue(!isDispatchThread());

  final Semaphore semaphore = new Semaphore();
  semaphore.down();
  Runnable runnable1 = new Runnable() {
    @Override
    public void run() {
      try {
        runnable.run();
      }
      finally {
        semaphore.up();
      }
    }

    @NonNls
    public String toString() {
      return "InvokeAndWait[" + runnable.toString() + "]";
    }
  };
  invokeLater(runnable1, modalityState);
  semaphore.waitFor();
}
 

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

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