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 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 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 boolean closeProject(
@NotNull final Project project,
final boolean save,
final boolean dispose,
boolean checkCanClose) {
if (isLight(project)) {
throw new AssertionError("must not close light project");
}
if (!isProjectOpened(project)) return true;
if (checkCanClose && !canClose(project)) return false;
final ShutDownTracker shutDownTracker = ShutDownTracker.getInstance();
shutDownTracker.registerStopperThread(Thread.currentThread());
try {
if (save) {
FileDocumentManager.getInstance().saveAllDocuments();
project.save();
}
if (checkCanClose && !ensureCouldCloseIfUnableToSave(project)) {
return false;
}
fireProjectClosing(project); // somebody can start progress here, do not wrap in write action
ApplicationManager.getApplication()
.runWriteAction(
new Runnable() {
@Override
public void run() {
synchronized (myOpenProjects) {
myOpenProjects.remove(project);
cacheOpenProjects();
myTestProjects.remove(project);
}
myChangedProjectFiles.remove(project);
fireProjectClosed(project);
if (dispose) {
Disposer.dispose(project);
}
}
});
} finally {
shutDownTracker.unregisterStopperThread(Thread.currentThread());
}
return true;
}
public boolean isReadAccessAllowed() {
Thread currentThread = Thread.currentThread();
return ourDispatchThread == currentThread
|| isExceptionalThreadWithReadAccess()
|| myActionsLock.isReadLockAcquired()
|| myActionsLock.isWriteLockAcquired()
|| isDispatchThread();
}
private static void assertIsDispatchThread(String message) {
if (ShutDownTracker.isShutdownHookRunning()) return;
final Thread currentThread = Thread.currentThread();
if (ourDispatchThread == currentThread) return;
if (EventQueue.isDispatchThread()) {
ourDispatchThread = currentThread;
}
if (ourDispatchThread == currentThread) return;
Integer safeCounter = ourEdtSafe.get();
if (safeCounter != null && safeCounter > 0) return;
LOG.error(
message,
"Current thread: " + describe(Thread.currentThread()),
"Our dispatch thread:" + describe(ourDispatchThread),
"SystemEventQueueThread: " + describe(getEventQueueThread()));
}
public void assertReadAccessAllowed() {
if (myHeadlessMode) return;
if (!isReadAccessAllowed()) {
LOG.error(
"Read access is allowed from event dispatch thread or inside read-action only (see com.intellij.openapi.application.Application.runReadAction())",
"Current thread: " + describe(Thread.currentThread()),
"Our dispatch thread:" + describe(ourDispatchThread),
"SystemEventQueueThread: " + describe(getEventQueueThread()));
}
}
ReadAccessToken(boolean explicit) {
myExplicit = explicit;
LOG.assertTrue(
!Thread.holdsLock(PsiLock.LOCK),
"Thread must not hold PsiLock while performing readAction");
try {
myActionsLock.readLock().acquire();
if (myExplicit) acquired();
} catch (InterruptedException e) {
throw new RuntimeInterruptedException(e);
}
}
public Thread newThread(Runnable r) {
final Thread thread =
new Thread(r, "ApplicationImpl pooled thread " + i++) {
public void interrupt() {
if (LOG.isDebugEnabled()) {
LOG.debug("Interrupted worker, will remove from pool");
}
super.interrupt();
}
public void run() {
try {
super.run();
} catch (Throwable t) {
if (LOG.isDebugEnabled()) {
LOG.debug("Worker exits due to exception", t);
}
}
}
};
thread.setPriority(Thread.NORM_PRIORITY - 1);
return thread;
}
public void assertIsDispatchThread(@Nullable final JComponent component) {
if (component == null) return;
Thread curThread = Thread.currentThread();
if (ourDispatchThread == curThread) {
return;
}
if (Boolean.TRUE.equals(component.getClientProperty(WAS_EVER_SHOWN))) {
assertIsDispatchThread();
} else {
final JRootPane root = component.getRootPane();
if (root != null) {
component.putClientProperty(WAS_EVER_SHOWN, Boolean.TRUE);
assertIsDispatchThread();
}
}
}
@NonNls
private static String describe(Thread o) {
if (o == null) return "null";
return o.toString() + " " + System.identityHashCode(o);
}
public boolean isWriteAccessAllowed() {
return myActionsLock.isWriteLockAcquired(Thread.currentThread());
}