public void runReadAction(@NotNull final Runnable action) { /** * if we are inside read action, do not try to acquire read lock again since it will deadlock if * there is a pending writeAction see {@link * com.intellij.util.concurrency.ReentrantWriterPreferenceReadWriteLock#allowReader()} */ if (isReadAccessAllowed()) { action.run(); return; } LOG.assertTrue( !Thread.holdsLock(PsiLock.LOCK), "Thread must not hold PsiLock while performing readAction"); try { myActionsLock.readLock().acquire(); } catch (InterruptedException e) { throw new RuntimeInterruptedException(e); } try { action.run(); } finally { myActionsLock.readLock().release(); } }
public boolean tryRunReadAction(@NotNull Runnable action) { /** * if we are inside read action, do not try to acquire read lock again since it will deadlock if * there is a pending writeAction see {@link * com.intellij.util.concurrency.ReentrantWriterPreferenceReadWriteLock#allowReader()} */ boolean mustAcquire = !isReadAccessAllowed(); if (mustAcquire) { LOG.assertTrue( myTestModeFlag || !Thread.holdsLock(PsiLock.LOCK), "Thread must not hold PsiLock while performing readAction"); try { if (!myActionsLock.readLock().attempt(0)) return false; } catch (InterruptedException e) { throw new RuntimeInterruptedException(e); } } try { action.run(); } finally { if (mustAcquire) { myActionsLock.readLock().release(); } } return true; }
public void runWriteAction(@NotNull final Runnable action) { final AccessToken token = acquireWriteActionLock(action.getClass()); try { action.run(); } finally { token.finish(); } }
public <T> T getCurrentWriteAction(@Nullable Class<T> actionClass) { assertCanRunWriteAction(); for (int i = myWriteActionsStack.size() - 1; i >= 0; i--) { Runnable action = myWriteActionsStack.get(i); if (actionClass == null || ReflectionCache.isAssignable(actionClass, action.getClass())) return (T) action; } return null; }
public void runReadAction(@NotNull final Runnable action) { final AccessToken token = acquireReadActionLockImpl(false); try { action.run(); } finally { token.finish(); } }
public void exit(final boolean force) { if (!force && getDefaultModalityState() != ModalityState.NON_MODAL) { return; } Runnable runnable = new Runnable() { public void run() { if (!force) { if (!showConfirmation()) { saveAll(); myExitCode = 0; return; } } getMessageBus().syncPublisher(AppLifecycleListener.TOPIC).appClosing(); FileDocumentManager.getInstance().saveAllDocuments(); saveSettings(); if (!canExit()) { myExitCode = 0; return; } final boolean success = disposeSelf(); if (!success || isUnitTestMode()) { myExitCode = 0; return; } System.exit(myExitCode); } }; if (!isDispatchThread()) { invokeLater(runnable, ModalityState.NON_MODAL); } else { runnable.run(); } }
public void runWriteAction(@NotNull final Runnable action) { assertCanRunWriteAction(); ActivityTracker.getInstance().inc(); fireBeforeWriteActionStart(action); final AtomicBoolean stopped = new AtomicBoolean(false); if (ourDumpThreadsOnLongWriteActionWaiting > 0) { executeOnPooledThread( new Runnable() { @Override public void run() { while (!stopped.get()) { try { Thread.sleep(ourDumpThreadsOnLongWriteActionWaiting); if (!stopped.get()) { PerformanceWatcher.getInstance().dumpThreads(true); } } catch (InterruptedException ignored) { } } } }); } LOG.assertTrue( myActionsLock.isWriteLockAcquired(Thread.currentThread()) || !Thread.holdsLock(PsiLock.LOCK), "Thread must not hold PsiLock while performing writeAction"); try { myActionsLock.writeLock().acquire(); } catch (InterruptedException e) { throw new RuntimeInterruptedException(e); } stopped.set(true); try { myWriteActionsStack.push(action); fireWriteActionStarted(action); action.run(); } finally { try { fireWriteActionFinished(action); myWriteActionsStack.pop(); } finally { myActionsLock.writeLock().release(); } } }
public void runEdtSafeAction(@NotNull Runnable runnable) { Integer value = ourEdtSafe.get(); if (value == null) { value = Integer.valueOf(0); } ourEdtSafe.set(value + 1); try { runnable.run(); } finally { int newValue = ourEdtSafe.get() - 1; ourEdtSafe.set(newValue >= 1 ? newValue : null); } }
public void invokeAndWait(@NotNull Runnable runnable, @NotNull ModalityState modalityState) { if (isDispatchThread()) { LOG.error("invokeAndWait must not be called from event queue thread"); runnable.run(); return; } if (isExceptionalThreadWithReadAccess()) { // OK if we're in exceptional thread. LaterInvocator.invokeAndWait(runnable, modalityState); return; } if (myActionsLock.isReadLockAcquired()) { LOG.error("Calling invokeAndWait from read-action leads to possible deadlock."); } LaterInvocator.invokeAndWait(runnable, modalityState); }